Android OpenCV基础（一、OpenCV入门）

一、OpenCV概述

  OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供了很多函数，这些函数非常高效地实现了计算机视觉算法（最基本的滤波到高级的物体检测皆有涵盖）。

  OpenCV 的应用领域非常广泛，包括图像拼接、图像降噪、产品质检、人机交互、人脸识别、动作识别、动作跟踪、无人驾驶等。OpenCV 还提供了机器学习模块，你可以使用正态贝叶斯、K最近邻、支持向量机、决策树、随机森林、人工神经网络等机器学习算法。

二、OpenCV框架

2.1 OpenCV整体结构

  OpenCV 使用 C/C++ 开发，同时也提供了 Python、Java、MATLAB等其他语言的接口，并且提供 Windows、Android（Android库下载）、ios等平台的接口。

  OpenCV是由很多模块组成的，这些模块可以分成很多层：

• 最底层是基于硬件加速层（HAL）的各种硬件优化。
• 再上一层是OpenCV核心层，包括core、imgproc、calib3d、objdetect等。
• 再上一层是opencv_contrib，可以理解为OpenCV的扩展模块，里面包含一些最新的算法，不过API尚未稳定或未充分测试。
• 接下来是语言绑定和示例应用程序。
• 处于最上层的是 OpenCV 和操作系统的交互。

2.2 OpenCV核心模块

  我们主要关注OpenCV核心层，下图显示了 OpenCV核心层中包含的模块：

  在OpenCV github项目中可以看到Opencv核心的所有模块：

  如果项目中只需要用到OpenCV中的部分模块，并且项目体积要求比较严格，可根据项目需要裁剪OpenCV，把需要的模块单独打包成so。

三、集成OpenCV

  在集成OpenCV之前，需要了解一些NDK开发的基础知识（可以参考：Android NDK开发基础）。

  要集成OpenCV，可以从OpenCV release页面直接下载官方编译产物，或者自己去OpenCV github下载并按需编译产物。本文主要介绍官方提供的Android平台OpenCV-4.5.5版本集成方式。

3.1 产物介绍

  在下载了官方Android平台OpenCV-4.5.5产物后，里面内容如下：

• sample：官方示例；
• sdk：opencv核心sdk；
  • java：opencv java层；java层包结构与上述opencv模块划分一致，里面提供了对应java类，实际实现采用jni的形式实现；
  • libcxx_helper：存放CMakeList；
  • native：opencv native层；
    • jni：opencv jni层；
    • libs：opencv包含所有核心库及jni的动态库；
    • staticlibs：openvc核心各个模块的静态库；
    • 3rdparty：第三方库；
      
        官方产物大小共900M，我们从中选择我们需要的部分进行集成即可，或者从静态库中选择业务中所需要的.a自己编译产物进行集成。

3.2 Java + Native集成

  如果项目中需要在java层编写OpenCV代码，则需要集成java层及native层。

3.2.1 OpenCV Java类简介

  在上述OpenCV java目录中，除了提供了OpenCV核心模块的java类之外，org.opencv.android包内还提供了OpenCVNativeLoader加载类、JavaCameraView、CameraGLSurfaceView相机封装等。

  OpenCV java目录中提供的核心模块java类，底层实现都是通过native层实现，java层只引用了native层对象的地址，例如Opencv基础图像类Mat：

public class Mat {
    /**
    * Native object address
    * native层对象地址
    **/
    public final long nativeObj;

    public Mat(long addr) {
        if (addr == 0)
            throw new UnsupportedOperationException("Native object address is NULL");
        nativeObj = addr;
    }

    // javadoc: Mat::Mat()
    public Mat() {
        nativeObj = n_Mat();
    }
    // C++: Mat::Mat()
    private static native long n_Mat();
    
    // javadoc: Mat::dims()
    public int dims() {
        return n_dims(nativeObj);
    }
    // C++: int Mat::dims()
    private static native int n_dims(long nativeObj);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

  可以看到其对应的jni中，都是调用了opencv核心模块的c/c++方法：

#include "opencv2/core.hpp"

#define LOG_TAG "org.opencv.core.Mat"
#include "common.h"

using namespace cv;
/*
 * Class:     org_opencv_core_Mat
 * Method:    n_Mat
 * Signature: (IIILjava/nio/ByteBuffer;J)J
 *
 * Mat::Mat(int rows, int cols, int type, void* data, size_t step)
 */
JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__IIILjava_nio_ByteBuffer_2J
  (JNIEnv* env, jclass, jint rows, jint cols, jint type, jobject data, jlong step);

JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__IIILjava_nio_ByteBuffer_2J
  (JNIEnv* env, jclass, jint rows, jint cols, jint type, jobject data, jlong step)
{
    static const char method_name[] = "Mat::n_1Mat__IIILjava_nio_ByteBuffer_2J()";
    try {
        LOGD("%s", method_name);
        return (jlong) new Mat(rows, cols, type, (void*)env->GetDirectBufferAddress(data), (size_t)step);
    } catch(const std::exception &e) {
        throwJavaException(env, &e, method_name);
    } catch (...) {
        throwJavaException(env, 0, method_name);
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.2.2 集成内容

  要在项目中集成OpenCV，首先我们新建一个opencv_sdk模块，将官网产物中的java目录、libcxx_helper目录、native下的lib目录（架构只选择了主流的arm64-v8a、armeabi-v7a），如下所示：

  至此，opencv_sdk模块集成完毕，可以在其他模块中通过java对象调用opencv的方法。

3.2.3 简单用法

  下面列举一个简单的例子：在java层通过bitmap创建一个OpenCV的Mat，并打印log。首先在build.gradle中加入依赖：

dependencies {
    implementation(project(':opencv_sdk'))
}
1
2
3

  然后就可以在app模块使用OpenCV的java类了：

Bitmap bitmap = BitmapFactory.decodeResource(this.getResources(), R.drawable.adventure_time);
// OpenCV提供的加载libopencv_java4.so的封装类
OpenCVNativeLoader openCVNativeLoader = new OpenCVNativeLoader();
openCVNativeLoader.init();
ByteBuffer buffer = ByteBuffer.allocateDirect(bitmap.getByteCount());
bitmap.copyPixelsToBuffer(buffer);
Mat mat = new Mat(bitmap.getHeight(), bitmap.getWidth(), CvType.CV_8UC4, buffer);
Log.d("OpenCV", "mat channels:"+mat.channels()+", cols:"+mat.cols()+", rows:"+mat.rows());
1
2
3
4
5
6
7
8

  运行结果如下，说明Mat已经创建成功：

D/OpenCV: mat channels:4, cols:3000, rows:4500
1

3.3 Native集成

  如果项目中只需要在native层编写OpenCV代码，则只需要集成native层即可，可以删除上述的java目录以减小包体积。

  项目中的opencv_sdk模块中只需要引入OpenCV头文件（在官网产物的OpenCV-android-sdk/sdk/native/jni/include目录下）和OpenCV动态库，如下所示：

3.3.1 新建native模块

  首先新建一个sample_native模块来存放jni及native代码，模块结构如下：

3.3.2 配置cmake

  在sample_native模块的build.gradle中配置cmake及opencv：

android {
    defaultConfig {
        ndk {
            // 指定编译的abi架构
            abiFilters "armeabi-v7a", "arm64-v8a"
        }
        externalNativeBuild {
            // cmake配置
            cmake {
                cppFlags "-std=c++11 -frtti -fexceptions"
                arguments "-DANDROID_STL=c++_shared"
                arguments "-DANDROID_TOOLCHAIN=clang"
                // 配置opencv头文件目录和动态库目录
                arguments "-DOPENCV_HEADER_DIR=${project.rootProject.project("opencv_sdk").file("include").path}"
                arguments "-DOPENCV_LIBS_DIR=${project.rootProject.project("opencv_sdk").file("native/libs").path}"
            }
        }
    }
    externalNativeBuild {
        cmake {
            // 构建脚本路径
            path "src/main/cpp/CMakeLists.txt"
            version "3.10.2"
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  到此就完成了cmake的基本配置，里面通过arguments配置了opencv头文件和动态库的位置，方面后面代码中引入。

3.3.3 编写jni代码

  在sample_native模块中，创建jni接口如下：

public class OpenCVSample {

    private static boolean isLoadSuccess = false;

    static {
        try {
            System.loadLibrary("native-lib");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    public static native void createMat(Bitmap bitmap);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  接着创建cpp目录，并创建native-lib.h头文件和native-lib.cpp文件，以及CMakeLists.txt，在CMakeLists.txt中配置opencv依赖如下：

# cmake最低版本号
cmake_minimum_required(VERSION 3.4.1)

# 导入opencv头文件
include_directories(${OPENCV_HEADER_DIR})

# add_library:把一个library添加到工程
add_library(
        native-lib
        SHARED
        native-lib.cpp)

# 添加一个已构建的库，使用IMPORTED
add_library(opencv_java4 SHARED IMPORTED)
set_target_properties(opencv_java4
        PROPERTIES IMPORTED_LOCATION
        "${OPENCV_LIBS_DIR}/${ANDROID_ABI}/libopencv_java4.so")

# 首个参数是target,后面的参数是item；target必须先用add_library()创建过；
target_link_libraries(
        native-lib
        opencv_java4
        jnigraphics
        log )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  然后把JNI对应的头文件native-lib.h代码完善如下：

#include <jni.h>
#include <android/log.h>
#include <android/bitmap.h>

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/imgproc/types_c.h>

#define TAG    "NativeLibSample"
#define AndroidLOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)

extern "C"
JNIEXPORT void JNICALL
Java_com_bc_sample_OpenCVSample_createMat(
        JNIEnv* env,
        jclass thiz, jobject bitmap);

void bitmapToMat(JNIEnv *env, jobject bitmap, cv::Mat &dst);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

  然后，把JNI对应的native-lib.cpp文件代码完善如下，这里在c++代码中创建了Mat，然后打印出Mat的信息：

#include "native-lib.h"

extern "C"
JNIEXPORT void JNICALL
Java_com_bc_sample_OpenCVSample_createMat(
        JNIEnv* env,
        jclass thiz, jobject bitmap) {
    cv::Mat rgbMat;
    // 把java层的bitmap转换为Mat
    bitmapToMat(env, bitmap, rgbMat);
    // log输出Mat的信息
    AndroidLOGD("native mat channels:%d, cols:%d, rows:%d", rgbMat.channels(), rgbMat.cols, rgbMat.rows);
}

void bitmapToMat(JNIEnv *env, jobject bitmap, cv::Mat &dst) {
    AndroidBitmapInfo info;
    void *pixels = 0;
    try {
        CV_Assert(AndroidBitmap_getInfo(env, bitmap, &info) >= 0);
        CV_Assert(info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 ||
                  info.format == ANDROID_BITMAP_FORMAT_RGB_565);
        CV_Assert(AndroidBitmap_lockPixels(env, bitmap, &pixels) >= 0);
        CV_Assert(pixels);
        dst.create(info.height, info.width, CV_8UC4);
        if (info.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {
            cv::Mat tmp(info.height, info.width, CV_8UC4, pixels);
            tmp.copyTo(dst);
        } else {
            cv::Mat tmp(info.height, info.width, CV_8UC2, pixels);
            cvtColor(tmp, dst, CV_BGR5652RGBA);
        }
        AndroidBitmap_unlockPixels(env, bitmap);
        return;
    }catch (...) {
        AndroidBitmap_unlockPixels(env, bitmap);
        jclass je = env->FindClass("java/lang/Exception");
        env->ThrowNew(je, "Unknown exception in JNI code {nBitmapToMat}");
        return;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3.3.4 运行程序

  最后，在代码中就可以按如下方式调用刚才创建的jni方法：

Bitmap bitmap = BitmapFactory.decodeResource(this.getResources(), R.drawable.adventure_time);
OpenCVSample.createMat(bitmap);
1
2

  运行结果如下，说明Mat已经创建成功：

D/NativeLibSample: native mat channels:4, cols:3000, rows:4500
1

3.4.5 其他

  如果在打包过程中碰到了动态库重复的问题，可以在app模块的build.gradle中添加如下配置解决：

android {
    packagingOptions {
        pickFirst 'lib/arm64-v8a/libc++_shared.so'
        pickFirst 'lib/armeabi-v7a/libc++_shared.so'
        pickFirst 'lib/arm64-v8a/libopencv_java4.so'
        pickFirst 'lib/armeabi-v7a/libopencv_java4.so'
    }
}
1
2
3
4
5
6
7
8

The End

欢迎关注我，一起解锁更多技能：BC的掘金主页～