添加opencv测试代码

ifinver · Apr 7, 2022 · d7de638 · d7de638
1 parent a6e11d3
commit d7de638
Show file tree

Hide file tree

Showing 16 changed files with 2,184 additions and 20,824 deletions.
diff --git a/finengine/src/main/CMakeLists.txt b/finengine/src/main/CMakeLists.txt
@@ -35,6 +35,7 @@ add_library(fin-engine-lib
             ${PROJECT_SOURCE_DIR}/cpp/finrender/FinRenderHolder.cpp
             #===============face detect blew=============================
             ${PROJECT_SOURCE_DIR}/cpp/facedetect/facedetector.cpp
+            ${PROJECT_SOURCE_DIR}/cpp/facedetect/DetectionBasedTracker_jni.cpp
 #            ${PROJECT_SOURCE_DIR}/cpp/facedetect/arcsoft/arcsoft.cpp
             #===============effects blew=================================
 #            ${PROJECT_SOURCE_DIR}/cpp/effects/effects.cpp

diff --git a/finengine/src/main/cpp/facedetect/DetectionBasedTracker_jni.cpp b/finengine/src/main/cpp/facedetect/DetectionBasedTracker_jni.cpp
@@ -0,0 +1,251 @@
+#include "DetectionBasedTracker_jni.h"
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect.hpp>
+
+#include <string>
+#include <vector>
+
+#include <android/log.h>
+
+#define LOG_TAG "FaceDetection/DetectionBasedTracker"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+
+using namespace std;
+using namespace cv;
+
+inline void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat)
+{
+    mat = Mat(v_rect, true);
+}
+
+class CascadeDetectorAdapter: public DetectionBasedTracker::IDetector
+{
+public:
+    CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):
+            IDetector(),
+            Detector(detector)
+    {
+        LOGD("CascadeDetectorAdapter::Detect::Detect");
+        CV_Assert(detector);
+    }
+
+    void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects)
+    {
+        LOGD("CascadeDetectorAdapter::Detect: begin");
+        LOGD("CascadeDetectorAdapter::Detect: scaleFactor=%.2f, minNeighbours=%d, minObjSize=(%dx%d), maxObjSize=(%dx%d)", scaleFactor, minNeighbours, minObjSize.width, minObjSize.height, maxObjSize.width, maxObjSize.height);
+        Detector->detectMultiScale(Image, objects, scaleFactor, minNeighbours, 0, minObjSize, maxObjSize);
+        LOGD("CascadeDetectorAdapter::Detect: end");
+    }
+
+    virtual ~CascadeDetectorAdapter()
+    {
+        LOGD("CascadeDetectorAdapter::Detect::~Detect");
+    }
+
+private:
+    CascadeDetectorAdapter();
+    cv::Ptr<cv::CascadeClassifier> Detector;
+};
+
+struct DetectorAgregator
+{
+    cv::Ptr<CascadeDetectorAdapter> mainDetector;
+    cv::Ptr<CascadeDetectorAdapter> trackingDetector;
+
+    cv::Ptr<DetectionBasedTracker> tracker;
+    DetectorAgregator(cv::Ptr<CascadeDetectorAdapter>& _mainDetector, cv::Ptr<CascadeDetectorAdapter>& _trackingDetector):
+            mainDetector(_mainDetector),
+            trackingDetector(_trackingDetector)
+    {
+        CV_Assert(_mainDetector);
+        CV_Assert(_trackingDetector);
+
+        DetectionBasedTracker::Parameters DetectorParams;
+        tracker = makePtr<DetectionBasedTracker>(mainDetector, trackingDetector, DetectorParams);
+    }
+};
+
+JNIEXPORT jlong JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeCreateObject
+(JNIEnv * jenv, jclass, jstring jFileName, jint faceSize)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeCreateObject enter");
+    const char* jnamestr = jenv->GetStringUTFChars(jFileName, NULL);
+    string stdFileName(jnamestr);
+    jlong result = 0;
+
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeCreateObject");
+
+    try
+    {
+        cv::Ptr<CascadeDetectorAdapter> mainDetector = makePtr<CascadeDetectorAdapter>(
+            makePtr<CascadeClassifier>(stdFileName));
+        cv::Ptr<CascadeDetectorAdapter> trackingDetector = makePtr<CascadeDetectorAdapter>(
+            makePtr<CascadeClassifier>(stdFileName));
+        result = (jlong)new DetectorAgregator(mainDetector, trackingDetector);
+        if (faceSize > 0)
+        {
+            mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+            //trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeCreateObject caught cv::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 of DetectionBasedTracker.nativeCreateObject()");
+        return 0;
+    }
+
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeCreateObject exit");
+    return result;
+}
+
+JNIEXPORT void JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeDestroyObject
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeDestroyObject");
+
+    try
+    {
+        if(thiz != 0)
+        {
+            ((DetectorAgregator*)thiz)->tracker->stop();
+            delete (DetectorAgregator*)thiz;
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeestroyObject caught cv::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 of DetectionBasedTracker.nativeDestroyObject()");
+    }
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeDestroyObject exit");
+}
+
+JNIEXPORT void JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeStart
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeStart");
+
+    try
+    {
+        ((DetectorAgregator*)thiz)->tracker->run();
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStart caught cv::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 of DetectionBasedTracker.nativeStart()");
+    }
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeStart exit");
+}
+
+JNIEXPORT void JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeStop
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeStop");
+
+    try
+    {
+        ((DetectorAgregator*)thiz)->tracker->stop();
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStop caught cv::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 of DetectionBasedTracker.nativeStop()");
+    }
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeStop exit");
+}
+
+JNIEXPORT void JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeSetFaceSize
+(JNIEnv * jenv, jclass, jlong thiz, jint faceSize)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeSetFaceSize -- BEGIN");
+
+    try
+    {
+        if (faceSize > 0)
+        {
+            ((DetectorAgregator*)thiz)->mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+            //((DetectorAgregator*)thiz)->trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStop caught cv::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 of DetectionBasedTracker.nativeSetFaceSize()");
+    }
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeSetFaceSize -- END");
+}
+
+
+JNIEXPORT void JNICALL Java_com_ifinver_finengine_DetectionBasedTracker_nativeDetect
+(JNIEnv * jenv, jclass, jlong thiz, jlong imageGray, jlong faces)
+{
+    LOGD("Java_com_ifinver_finengine_DetectionBasedTracker_nativeDetect");
+
+    try
+    {
+        vector<Rect> RectFaces;
+        ((DetectorAgregator*)thiz)->tracker->process(*((Mat*)imageGray));
+        ((DetectorAgregator*)thiz)->tracker->getObjects(RectFaces);
+        *((Mat*)faces) = Mat(RectFaces, true);
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeCreateObject caught cv::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_com_ifinver_finengine_DetectionBasedTracker_nativeDetect END");
+}
diff --git a/finengine/src/main/cpp/facedetect/DetectionBasedTracker_jni.h b/finengine/src/main/cpp/facedetect/DetectionBasedTracker_jni.h
diff --git a/finengine/src/main/cpp/facedetect/facedetector.cpp b/finengine/src/main/cpp/facedetect/facedetector.cpp
@@ -44,12 +44,7 @@ Java_com_ifinver_finengine_FaceDetector_nativeProcess(JNIEnv *env, jclass, jbyte
 //        cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
         equalizeHist( small, small );
         vector<Rect> *result = new vector<Rect>;
-        mXcFaceDetector->detectMultiScale(small, *result, 1.1, 2,
-                                          0
-                                          //                                          |CASCADE_FIND_BIGGEST_OBJECT
-                                          //                                          |CASCADE_DO_ROUGH_SEARCH
-                                          | CASCADE_SCALE_IMAGE,
-                                          Size(30, 30));
+        mXcFaceDetector->detectMultiScale(small, *result);
         for(int i = 0; i < result->size();i++){
             (*result)[i].width /= scale;
             (*result)[i].height /= scale;

diff --git a/finengine/src/main/java/com/ifinver/finengine/DetectionBasedTracker.java b/finengine/src/main/java/com/ifinver/finengine/DetectionBasedTracker.java
@@ -0,0 +1,41 @@
+package com.ifinver.finengine;
+
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+
+public class DetectionBasedTracker
+{
+    public DetectionBasedTracker(String cascadeName, int minFaceSize) {
+        mNativeObj = nativeCreateObject(cascadeName, minFaceSize);
+    }
+
+    public void start() {
+        nativeStart(mNativeObj);
+    }
+
+    public void stop() {
+        nativeStop(mNativeObj);
+    }
+
+    public void setMinFaceSize(int size) {
+        nativeSetFaceSize(mNativeObj, size);
+    }
+
+    public void detect(Mat imageGray, MatOfRect faces) {
+        nativeDetect(mNativeObj, imageGray.getNativeObjAddr(), faces.getNativeObjAddr());
+    }
+
+    public void release() {
+        nativeDestroyObject(mNativeObj);
+        mNativeObj = 0;
+    }
+
+    private long mNativeObj = 0;
+
+    private static native long nativeCreateObject(String cascadeName, int minFaceSize);
+    private static native void nativeDestroyObject(long thiz);
+    private static native void nativeStart(long thiz);
+    private static native void nativeStop(long thiz);
+    private static native void nativeSetFaceSize(long thiz, int size);
+    private static native void nativeDetect(long thiz, long inputImage, long faces);
+}
diff --git a/finengine/src/main/java/com/ifinver/finengine/FaceDetector.java b/finengine/src/main/java/com/ifinver/finengine/FaceDetector.java
@@ -25,7 +25,7 @@ public class FaceDetector {
 
     public static boolean init(Context ctx){
         if(!initialized) {
-            InputStream faceLibInputStream = ctx.getResources().openRawResource(R.raw.haarcascade_frontalface_alt2);
+            InputStream faceLibInputStream = ctx.getResources().openRawResource(R.raw.lbpcascade_frontalface);
             File dir = new File(Environment.getExternalStorageDirectory(), ROOT_DIR_NAME);
             File faceModelDir = new File(dir,DIR_NAME);
             if(!faceModelDir.exists()){