android 结合 opencv项目（NDK、OpenCV、android，官方Demo人脸识别）

第一个android结合 opencv项目（NDK、OpenCV、android人脸识别）

（2017.5.16更改，见绿色）

前提条件：已经搭建好jdk 和eclipse 开发android 和插件CDT (eclipse c++)的环境

在命令行窗口输入：java –version 如果显示相应版本代表jdk环境搭建成功

在命令行窗口输入：android –version 如果显示相应版本代表eclipseandroid环境搭建成功

第一步：配置eclipseNDK 环境

1) ：下载NDK

http://www.cnblogs.com/yaotong/archive/2011/01/25/1943615.html

我下载的版本是android-ndk-r10e

2) ：配置NDK

先配置环境变量，我的NDK安装在E盘

配置主要是执行ndk-build.cmd

谷歌改良了ndk的开发流程，对于Windows环境下NDK的开发，如果使用的NDK是r7之前的版本，必须要安装Cygwin才能使用NDK。而在NDKr7开始，Google的Windows版的NDK提供了一个ndk-build.cmd的脚本，这样，就可以直接利用这个脚本编译，而不需要使用Cygwin了。只需要为Eclipse Android工程添加一个Builders，而为Eclipse配置的builder，其实就是在执行Cygwin，然后传递ndk-build作为参数，这样就能让Eclipse自动编译NDK了。（摘自博客http://www.cnblogs.com/yejiurui/p/3476565.html）

3) :配置Builders（其实有两种方法配置，先说第一种，个人觉得第二种更加方便）

第一种

新建一个android project 我的是（Demo_NDK）

鼠标右键选中该工程选择下面的Properties

在弹出窗口选中

点击右边new按钮出现

直接单击Program 弹出

在切到Refresh 页面

并点击右侧Specify Resources

点击Finish

再去到Build Options 页面

同样点击右侧Specify Resources选中刚才新建的项目

最后点击OK，完成操作

第二种

选择Window下拉列表，选中Preferences,再作如下操作

然后选中本项目右键下拉选择Android Tools 选中 add native support 完成操作

以上步骤完成NDK环境搭建

第二步：配置进行opencv在android运行的环境

1）：到官网http://opencv.org/downloads.html下载sdk

我下载的是OpenCV-2.4.10-android-sdk

下载后在eclipse 导入android project

选中OpenCV Library -2.4.10 ----

当然你全部导入也行

导入完成后如下

再右键点击刚才新建的项目选中下方Properties

点击OK 后，IDE 会自动 builder project 如果出现以下代表环境搭建好了

第三步：

上面两个步骤完成后，我以官方demo opencv-sample-face-detection 来展示如何利用OPENCV来通过NDK和android相关联

建包，分别创建DetectionBasedTracker.java 和FdActity.java

结构如下

DetectionBasedTracker.java

用来写native方法（即本地方法，在C++环境运行）

代码如下

打开命令行进入这个项目的bin\classes目录（找到已经编译的.class文件）

输入命令：javah org.opencv.samples.facedetect.DetectionBasedTracker

org.opencv.samples.facedetect是类包路径

DetectionBasedTracker 是类名

将在bin\classes目录下生成org_opencv_samples_facedetect_DetectionBasedTracker.h文件，这个文件就是我们首先要拿到的文件

将其复制粘贴到项目的JNI 目录下

同时创建Android.mk 文件（配置文件）

LOCAL_MODULE :=Demo_NDK #标识你在Android.mk文件中描述的每个模板

这个标识着Java要调用的动态链接库

// Load native library after(!) OpenCV initialization

System.loadLibrary("Demo_NDK");

LOCAL_C_INCLUDES :=E:/OpenCV-2.4.10-android-sdk/sdk/native/jni/include

这将指定opencv包的路径，（这个很坑，我之前没有指定这段代码的时候，在下面.cpp文件导入openCV包总是报找不到包的错误）

再创建Application.mk 文件（配置文件）

再创建org_opencv_samples_facedetect_DetectionBasedTracker.cpp文件，在里面编写openCV代码，分别对DetectionBasedTracker.java6个Native方法实现，代码如下

#include

#define LOG_TAG"FaceDetection/DetectionBasedTracker"

#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG,LOG_TAG, __VA_ARGS__))

usingnamespace std;

usingnamespace cv;

inlinevoidvector_Rect_to_Mat(vector<Rect>& v_rect,Mat& mat)

{

mat = Mat(v_rect, true);

}

JNIEXPORT jlongJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject

(JNIEnv* jenv,jclass,jstring jFileName,jint faceSize)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObjectenter");

constchar* jnamestr = jenv->GetStringUTFChars(jFileName, NULL);

string stdFileName(jnamestr);

jlong result = 0;

try

{

DetectionBasedTracker::Parameters DetectorParams;

if (faceSize > 0)

DetectorParams.minObjectSize = faceSize;

result = (jlong)newDetectionBasedTracker(stdFileName,DetectorParams);

}

catch(cv::Exception& e)

{

LOGD("nativeCreateObject caughtcv::Exception:%s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeCreateObject caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code ofDetectionBasedTracker.nativeCreateObject()");

return 0;

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObjectexit");

return result;

}

JNIEXPORT voidJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObject

(JNIEnv* jenv,jclass,jlong thiz)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObjectenter");

try

{

if(thiz != 0)

{

((DetectionBasedTracker*)thiz)->stop();

delete (DetectionBasedTracker*)thiz;

}

catch(cv::Exception& e)

{

LOGD("nativeestroyObject caughtcv::Exception:%s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeDestroyObject caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code ofDetectionBasedTracker.nativeDestroyObject()");

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObjectexit");

}

JNIEXPORT voidJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStart

(JNIEnv* jenv,jclass,jlong thiz)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStartenter");

try

{

((DetectionBasedTracker*)thiz)->run();

}

catch(cv::Exception& e)

{

LOGD("nativeStart caughtcv::Exception: %s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeStart caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code ofDetectionBasedTracker.nativeStart()");

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStartexit");

}

JNIEXPORT voidJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStop

(JNIEnv* jenv,jclass,jlong thiz)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStopenter");

try

{

((DetectionBasedTracker*)thiz)->stop();

}

catch(cv::Exception& e)

{

LOGD("nativeStop caughtcv::Exception: %s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeStop caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code ofDetectionBasedTracker.nativeStop()");

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStopexit");

}

JNIEXPORT voidJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSize

(JNIEnv* jenv,jclass,jlong thiz,jint faceSize)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSizeenter");

try

{

if (faceSize > 0)

{

DetectionBasedTracker::Parameters DetectorParams = \

((DetectionBasedTracker*)thiz)->getParameters();

DetectorParams.minObjectSize = faceSize;

((DetectionBasedTracker*)thiz)->setParameters(DetectorParams);

}

catch(cv::Exception& e)

{

LOGD("nativeStop caughtcv::Exception: %s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeSetFaceSize caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code ofDetectionBasedTracker.nativeSetFaceSize()");

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSizeexit");

}

JNIEXPORT voidJNICALLJava_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetect

(JNIEnv* jenv,jclass,jlong thiz,jlong imageGray,jlong faces)

{

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetectenter");

try

{

vector<Rect> RectFaces;

((DetectionBasedTracker*)thiz)->process(*((Mat*)imageGray));

((DetectionBasedTracker*)thiz)->getObjects(RectFaces);

vector_Rect_to_Mat(RectFaces, *((Mat*)faces));

}

catch(cv::Exception& e)

{

LOGD("nativeCreateObject caughtcv::Exception:%s", e.what());

jclass je = jenv->FindClass("org/opencv/core/CvException");

if(!je)

je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, e.what());

}

catch (...)

{

LOGD("nativeDetect caught unknown exception");

jclass je = jenv->FindClass("java/lang/Exception");

jenv->ThrowNew(je, "Unknown exception in JNI code DetectionBasedTracker.nativeDetect()");

}

LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetectexit");

}

然后完善DetectionBasedTracker.java 文件

packageorg.opencv.samples.facedetect;

import org.opencv.core.Mat;

importorg.opencv.core.MatOfRect;

publicclass DetectionBasedTracker

{

public DetectionBasedTracker(String cascadeName,int minFaceSize) {

mNativeObj =nativeCreateObject(cascadeName,minFaceSize);

}

publicvoid start() {

nativeStart(mNativeObj);

}

publicvoid stop() {

nativeStop(mNativeObj);

}

publicvoid setMinFaceSize(int size) {

nativeSetFaceSize(mNativeObj, size);

}

publicvoid detect(Mat imageGray, MatOfRect faces) {

nativeDetect(mNativeObj,imageGray.getNativeObjAddr(), faces.getNativeObjAddr());

}

publicvoid release() {

nativeDestroyObject(mNativeObj);

mNativeObj = 0;

}

privatelongmNativeObj = 0;

privatestaticnativelongnativeCreateObject(String cascadeName, int minFaceSize);

privatestaticnativevoidnativeDestroyObject(long thiz);

privatestaticnativevoidnativeStart(longthiz);

privatestaticnativevoidnativeStop(longthiz);

privatestaticnativevoidnativeSetFaceSize(longthiz,intsize);

privatestaticnativevoidnativeDetect(longthiz,longinputImage,longfaces);

}

接下来是FdActivity.java主界面，代码如下

packageorg.opencv.samples.facedetect;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

importorg.opencv.android.BaseLoaderCallback;

importorg.opencv.android.CameraBridgeViewBase;

importorg.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;

importorg.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;

importorg.opencv.android.LoaderCallbackInterface;

importorg.opencv.android.OpenCVLoader;

import org.opencv.core.Core;

import org.opencv.core.Mat;

import org.opencv.core.MatOfRect;

import org.opencv.core.Rect;

import org.opencv.core.Scalar;

import org.opencv.core.Size;

import org.opencv.objdetect.CascadeClassifier;

import android.app.Activity;

import android.content.Context;

importandroid.content.pm.ActivityInfo;

import android.os.Bundle;

import android.util.Log;

import android.view.Menu;

import android.view.MenuItem;

import android.view.WindowManager;

import com.example.demo_ndk.R;

public class FdActivity extendsActivity implements CvCameraViewListener2 {

private static final String TAG ="OCVSample::Activity";

private static final Scalar FACE_RECT_COLOR = newScalar(0, 255, 0, 255);

public static final int JAVA_DETECTOR = 0;

public static final int NATIVE_DETECTOR = 1;

private MenuItem mItemFace50;

private MenuItem mItemFace40;

private MenuItem mItemFace30;

private MenuItem mItemFace20;

private MenuItem mItemType;

private Mat mRgba;

private Mat mGray;

private File mCascadeFile;

private CascadeClassifier mJavaDetector;

private DetectionBasedTracker mNativeDetector;

private int mDetectorType = JAVA_DETECTOR;

private String[] mDetectorName;

private float mRelativeFaceSize = 0.2f;

private int mAbsoluteFaceSize = 0;

//在 mOpenCvCameraView 的回调接口onCameraFrame函数里面处理每一帧从相机获取到的图片。

private CameraBridgeViewBase mOpenCvCameraView;

private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {

@Override

public void onManagerConnected(intstatus) {

switch (status) {

caseLoaderCallbackInterface.SUCCESS:

{

Log.i(TAG, "OpenCVloaded successfully");

// Load native libraryafter(!) OpenCV initialization

System.loadLibrary("Demo_NDK");

try {

// load cascade filefrom application resources

InputStream is =getResources().openRawResource(R.raw.lbpcascade_frontalface);

//这里去加载人脸识别分类文件（lbpcascade_frontalface.XML 是XML文件，这都是利用Opencv给我们提供好的XML人脸识别分类文件，在opencv/source/data/目录下,这里把那个文件拉到了Raw资源文件里面，方便Android调用，如果要自己实现一个XML人脸识别分类文件的话，需要用到opencv_haartraining，来训练大量数据，最终生成XML人脸识别分类文件）

File cascadeDir =getDir("cascade", Context.MODE_PRIVATE);

mCascadeFile = new File(cascadeDir,"lbpcascade_frontalface.xml");

FileOutputStream os =new FileOutputStream(mCascadeFile);

byte[] buffer = newbyte[4096];

int bytesRead;

while ((bytesRead =is.read(buffer)) != -1) {

os.write(buffer, 0,bytesRead);

}

is.close();

os.close();

mJavaDetector = newCascadeClassifier(mCascadeFile.getAbsolutePath());

if(mJavaDetector.empty()) {

Log.e(TAG,"Failed to load cascade classifier");

mJavaDetector =null;

} else

Log.i(TAG,"Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());

mNativeDetector = newDetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);

cascadeDir.delete();

} catch (IOException e) {

e.printStackTrace();

Log.e(TAG, "Failedto load cascade. Exception thrown: " + e);

}

mOpenCvCameraView.enableView();

} break;

default:

{

super.onManagerConnected(status);

} break;

}

};

public FdActivity() {

mDetectorName = newString[2];

mDetectorName[JAVA_DETECTOR] ="Java";

mDetectorName[NATIVE_DETECTOR] ="Native (tracking)";

Log.i(TAG, "Instantiated new" + this.getClass());

}

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

Log.i(TAG, "calledonCreate");

super.onCreate(savedInstanceState);

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

//设置拍摄方向

系统默认

ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED

锁定直式

ActivityInfo.SCREEN_ORIENTATION_PORTRAIT

锁定横式

ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE

随使用者当下

ActivityInfo.SCREEN_ORIENTATION_USER

与活动线程下相同的设定

ActivityInfo.SCREEN_ORIENTATION_BEHIND

不随SENSOR改变

ActivityInfo.SCREEN_ORIENTATION_NOSENSOR

随SENSOR改变

ActivityInfo.SCREEN_ORIENTATION_SENSOR

this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

setContentView(R.layout.face_detect_surface_view);

mOpenCvCameraView =(CameraBridgeViewBase) findViewById(R.id.fd_activity_surface_view);

mOpenCvCameraView.setCvCameraViewListener(this);

}

@Override

public void onPause()

{

super.onPause();

if (mOpenCvCameraView != null)

mOpenCvCameraView.disableView();

}

@Override

public void onResume()

{

super.onResume();

OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this,mLoaderCallback);

}

public void onDestroy() {

super.onDestroy();

mOpenCvCameraView.disableView();

}

public void onCameraViewStarted(int width, int height) {

mGray = new Mat();

mRgba = new Mat();

}

public void onCameraViewStopped() {

mGray.release();

mRgba.release();

}

public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

//这里获取相机拍摄到的原图，彩色图

mRgba = inputFrame.rgba();

//这里获取相机拍摄到的灰度图，用来给下面检测人脸使用。

mGray = inputFrame.gray();

if (mAbsoluteFaceSize == 0) {

int height = mGray.rows();

if (Math.round(height * mRelativeFaceSize)> 0) {

mAbsoluteFaceSize =Math.round(height * mRelativeFaceSize);

}

mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);

}

MatOfRect faces = new MatOfRect();

if (mDetectorType == JAVA_DETECTOR) {

if (mJavaDetector != null)

//调用opencv的detectMultiScale（）检测函数，参数意义如下

mGray表示的是要检测的输入图像，faces表示检测到的目标序列,存储检测结果（坐标位置，长，宽），1.1表示
每次图像尺寸减小的比例为1.1，2表示每一个目标至少要被检测到3次才算是真的目标(因为周围的像素和不同的窗口大
小都可以检测到目标),2（其实是一个常量：CV_HAAR_SCALE_IMAGE）表示不是缩放分类器来检测，而是缩放图像，最后两个size()为检测目标的
最小最大尺寸

mJavaDetector.detectMultiScale(mGray, faces, 1.1, 2, 2, // TODO:objdetect.CV_HAAR_SCALE_IMAGE

newSize(mAbsoluteFaceSize, mAbsoluteFaceSize), new Size());

}

else if (mDetectorType ==NATIVE_DETECTOR) {

if (mNativeDetector != null)

mNativeDetector.detect(mGray,faces);

}

else {

Log.e(TAG, "Detection methodis not selected!");

}

Rect[] facesArray = faces.toArray();

for (int i = 0; i

//在原图mRgba上为每个检测到的人脸画一个绿色矩形

Core.rectangle(mRgba,facesArray[i].tl(), facesArray[i].br(), FACE_RECT_COLOR, 3);

//返回处理好的图像，返回后会直接显示在JavaCameraView上。

return mRgba;

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

Log.i(TAG, "calledonCreateOptionsMenu");

mItemFace50 = menu.add("Face size50%");

mItemFace40 = menu.add("Face size40%");

mItemFace30 = menu.add("Face size30%");

mItemFace20 = menu.add("Face size20%");

mItemType = menu.add(mDetectorName[mDetectorType]);

return true;

}

@Override

public boolean onOptionsItemSelected(MenuItem item) {

Log.i(TAG, "calledonOptionsItemSelected; selected item: " + item);

if (item == mItemFace50)

setMinFaceSize(0.5f);

else if (item == mItemFace40)

setMinFaceSize(0.4f);

else if (item == mItemFace30)

setMinFaceSize(0.3f);

else if (item == mItemFace20)

setMinFaceSize(0.2f);

else if (item == mItemType) {

int tmpDetectorType =(mDetectorType + 1) % mDetectorName.length;

item.setTitle(mDetectorName[tmpDetectorType]);

setDetectorType(tmpDetectorType);

}

return true;

}

private void setMinFaceSize(float faceSize) {

mRelativeFaceSize = faceSize;

mAbsoluteFaceSize = 0;

}

private void setDetectorType(int type) {

if (mDetectorType != type) {

mDetectorType = type;

if (type == NATIVE_DETECTOR) {

Log.i(TAG, "DetectionBased Tracker enabled");

mNativeDetector.start();

} else {

Log.i(TAG, "Cascadedetector enabled");

mNativeDetector.stop();

}

最后配置AndroidManifest.xml文件

<supports-screensandroid:resizeable="true"

android:smallScreens="true"

android:normalScreens="true"

android:largeScreens="true"

android:anyDensity="true"

<uses-permissionandroid:name="android.permission.CAMERA"/>

<uses-featureandroid:name="android.hardware.camera"android:required="false"/>

<uses-featureandroid:name="android.hardware.camera.autofocus"android:required="false"/>

<uses-featureandroid:name="android.hardware.camera.front"android:required="false"/>

<uses-featureandroid:name="android.hardware.camera.front.autofocus"android:required="false"/>

到此大功告成

运行结果如下

源代码已经上传至：

http://download.csdn.net/detail/wjb820728252/9725892

至此，也是我这段时间走过的坑，希望能帮助到刚入门这门槛的朋友，谢谢！

更多相关文章

随机推荐