Fix binary compatibility of opencv_contrib

modules/contrib/include/opencv2/contrib/contrib.hpp

@@ -857,6 +857,17 @@ namespace cv
         LDA(int num_components = 0) :
             _num_components(num_components) {};
 
+        // Initializes and performs a Discriminant Analysis with Fisher's
+        // Optimization Criterion on given data in src and corresponding labels
+        // in labels. If 0 (or less) number of components are given, they are
+        // automatically determined for given data in computation.
+        LDA(const Mat& src, vector<int> labels,
+                int num_components = 0) :
+                    _num_components(num_components)
+        {
+            this->compute(src, labels); //! compute eigenvectors and eigenvalues
+        }
+
         // Initializes and performs a Discriminant Analysis with Fisher's
         // Optimization Criterion on given data in src and corresponding labels
         // in labels. If 0 (or less) number of components are given, they are
@@ -917,7 +928,7 @@ namespace cv
         CV_WRAP virtual void train(InputArrayOfArrays src, InputArray labels) = 0;
 
         // Updates a FaceRecognizer.
-        CV_WRAP virtual void update(InputArrayOfArrays src, InputArray labels);
+        CV_WRAP void update(InputArrayOfArrays src, InputArray labels);
 
         // Gets a prediction from a FaceRecognizer.
         virtual int predict(InputArray src) const = 0;

modules/contrib/include/opencv2/contrib/detection_based_tracker.hpp

@@ -12,66 +12,17 @@ class DetectionBasedTracker
     public:
         struct Parameters
         {
+            int minObjectSize;
+            int maxObjectSize;
+            double scaleFactor;
             int maxTrackLifetime;
+            int minNeighbors;
             int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0
 
             Parameters();
         };
 
-        class IDetector
+        DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params);
-        {
-            public:
-                IDetector():
-                    minObjSize(96, 96),
-                    maxObjSize(INT_MAX, INT_MAX),
-                    minNeighbours(2),
-                    scaleFactor(1.1f)
-                {}
-                virtual ~IDetector() {}
-
-                virtual void detect(const cv::Mat& image, std::vector<cv::Rect>& objects) = 0;
-
-                void setMinObjectSize(const cv::Size& min)
-                {
-                    minObjSize = min;
-                }
-                void setMaxObjectSize(const cv::Size& max)
-                {
-                    maxObjSize = max;
-                }
-                cv::Size getMinObjectSize() const
-                {
-                    return minObjSize;
-                }
-                cv::Size getMaxObjectSize() const
-                {
-                    return maxObjSize;
-                }
-                float getScaleFactor()
-                {
-                    return scaleFactor;
-                }
-                void setScaleFactor(float value)
-                {
-                    scaleFactor = value;
-                }
-                int getMinNeighbours()
-                {
-                    return minNeighbours;
-                }
-                void setMinNeighbours(int value)
-                {
-                    minNeighbours = value;
-                }
-
-            protected:
-                cv::Size minObjSize;
-                cv::Size maxObjSize;
-                int minNeighbours;
-                float scaleFactor;
-        };
-
-        DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params);
         virtual ~DetectionBasedTracker();
 
         virtual bool run();
@@ -81,39 +32,19 @@ class DetectionBasedTracker
         virtual void process(const cv::Mat& imageGray);
 
         bool setParameters(const Parameters& params);
-        const Parameters& getParameters() const;
+        const Parameters& getParameters();
 
         
         typedef std::pair<cv::Rect, int> Object;
         virtual void getObjects(std::vector<cv::Rect>& result) const;
         virtual void getObjects(std::vector<Object>& result) const;
 
-        enum ObjectStatus
-        {
-            DETECTED_NOT_SHOWN_YET,
-            DETECTED,
-            DETECTED_TEMPORARY_LOST,
-            WRONG_OBJECT
-        };
-        struct ExtObject
-        {
-            int id;
-            cv::Rect location;
-            ObjectStatus status;
-            ExtObject(int _id, cv::Rect _location, ObjectStatus _status)
-                :id(_id), location(_location), status(_status)
-            {
-            }
-        };
-        virtual void getObjects(std::vector<ExtObject>& result) const;
-
-        virtual int addObject(const cv::Rect& location); //returns id of the new object
-
     protected:
         class SeparateDetectionWork;
         cv::Ptr<SeparateDetectionWork> separateDetectionWork;
         friend void* workcycleObjectDetectorFunction(void* p);
 
+
         struct InnerParameters
         {
             int numLastPositionsToTrack;
@@ -159,11 +90,11 @@ class DetectionBasedTracker
         std::vector<float> weightsPositionsSmoothing;
         std::vector<float> weightsSizesSmoothing;
 
-        cv::Ptr<IDetector> cascadeForTracking;
+        cv::CascadeClassifier cascadeForTracking;
+
 
         void updateTrackedObjects(const std::vector<cv::Rect>& detectedObjects);
         cv::Rect calcTrackedObjectPositionToShow(int i) const;
-        cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
         void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
 };
 

modules/contrib/src/detection_based_tracker.cpp

@@ -1,18 +1,10 @@
 #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID)
 #include "opencv2/contrib/detection_based_tracker.hpp"
 
-#if defined(DEBUG) || defined(_DEBUG)
-#undef DEBUGLOGS
 #define DEBUGLOGS 1
-#endif
-
-#ifndef DEBUGLOGS
-#define DEBUGLOGS 0
-#endif
 
 #ifdef ANDROID
 #include <android/log.h>
-#include <pthread.h>
 #define LOG_TAG "OBJECT_DETECTOR"
 #define LOGD0(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
 #define LOGI0(...) ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
@@ -65,7 +57,7 @@ void* workcycleObjectDetectorFunction(void* p);
 class DetectionBasedTracker::SeparateDetectionWork
 {
     public:
-        SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector);
+        SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, const std::string& cascadeFilename);
         virtual ~SeparateDetectionWork();
         bool communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions);
         bool run();
@@ -88,7 +80,7 @@ class DetectionBasedTracker::SeparateDetectionWork
     protected:
 
         DetectionBasedTracker& detectionBasedTracker;
-        cv::Ptr<DetectionBasedTracker::IDetector> cascadeInThread;
+        cv::CascadeClassifier cascadeInThread;
 
         pthread_t second_workthread;
         pthread_mutex_t mutex;
@@ -116,7 +108,7 @@ class DetectionBasedTracker::SeparateDetectionWork
         long long  timeWhenDetectingThreadStartedWork;
 };
 
-DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector)
+DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, const std::string& cascadeFilename)
     :detectionBasedTracker(_detectionBasedTracker),
     cascadeInThread(),
     isObjectDetectingReady(false),
@@ -124,10 +116,9 @@ DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBas
     stateThread(STATE_THREAD_STOPPED),
     timeWhenDetectingThreadStartedWork(-1)
 {
-    CV_Assert(!_detector.empty());
+    if(!cascadeInThread.load(cascadeFilename)) {
-
+        CV_Error(CV_StsBadArg, "DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork: Cannot load a cascade from the file '"+cascadeFilename+"'");
-    cascadeInThread = _detector;
+    }
-
     int res=0;
     res=pthread_mutex_init(&mutex, NULL);//TODO: should be attributes?
     if (res) {
@@ -222,7 +213,7 @@ void* workcycleObjectDetectorFunction(void* p)
 void DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
 {
     static double freq = getTickFrequency();
-    LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start");
+    LOGD0("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start");
     vector<Rect> objects;
 
     CV_Assert(stateThread==STATE_THREAD_WORKING_SLEEPING);
@@ -286,17 +277,20 @@ void DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
 
         int64 t1_detect=getTickCount();
 
-        cascadeInThread->detect(imageSeparateDetecting, objects);
+        int minObjectSize=detectionBasedTracker.parameters.minObjectSize;
+        Size min_objectSize = Size(minObjectSize, minObjectSize);
 
-        /*cascadeInThread.detectMultiScale( imageSeparateDetecting, objects,
+        int maxObjectSize=detectionBasedTracker.parameters.maxObjectSize;
+        Size max_objectSize(maxObjectSize, maxObjectSize);
+
+
+        cascadeInThread.detectMultiScale( imageSeparateDetecting, objects,
                 detectionBasedTracker.parameters.scaleFactor, detectionBasedTracker.parameters.minNeighbors, 0
                 |CV_HAAR_SCALE_IMAGE
                 ,
                 min_objectSize,
                 max_objectSize
                 );
-        */
-
         LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- end handling imageSeparateDetecting");
 
         if (!isWorking()) {
@@ -307,7 +301,6 @@ void DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
         int64 t2_detect = getTickCount();
         int64 dt_detect = t2_detect-t1_detect;
         double dt_detect_ms=((double)dt_detect)/freq * 1000.0;
-        (void)(dt_detect_ms);
 
         LOGI("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- objects num==%d, t_ms=%.4f", (int)objects.size(), dt_detect_ms);
 
@@ -401,7 +394,6 @@ bool DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThrea
         isObjectDetectingReady=false;
 
         double lastBigDetectionDuration = 1000.0 * (((double)(getTickCount()  - timeWhenDetectingThreadStartedWork )) / freq);
-        (void)(lastBigDetectionDuration);
         LOGD("DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread: lastBigDetectionDuration=%f ms", (double)lastBigDetectionDuration);
     }
 
@@ -433,7 +425,11 @@ bool DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThrea
 
 DetectionBasedTracker::Parameters::Parameters()
 {
+    minObjectSize=96;
+    maxObjectSize=INT_MAX;
+    scaleFactor=1.1;
     maxTrackLifetime=5;
+    minNeighbors=2;
     minDetectionPeriod=0;
 }
 
@@ -450,25 +446,29 @@ DetectionBasedTracker::InnerParameters::InnerParameters()
 
 }
 
-DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
+DetectionBasedTracker::DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params)
     :separateDetectionWork(),
-    parameters(params),
     innerParameters(),
-    numTrackedSteps(0),
+    numTrackedSteps(0)
-    cascadeForTracking(trackingDetector)
 {
-    CV_Assert( (params.maxTrackLifetime >= 0)
+    CV_Assert( (params.minObjectSize > 0)
-//            && (!mainDetector.empty())
+            && (params.maxObjectSize >= 0)
-            && (!trackingDetector.empty()) );
+            && (params.scaleFactor > 1.0)
+            && (params.maxTrackLifetime >= 0) );
 
-    if (!mainDetector.empty()) {
+    if (!cascadeForTracking.load(cascadeFilename)) {
-        separateDetectionWork = new SeparateDetectionWork(*this, mainDetector);
+        CV_Error(CV_StsBadArg, "DetectionBasedTracker::DetectionBasedTracker: Cannot load a cascade from the file '"+cascadeFilename+"'");
     }
 
+    parameters=params;
+
+    separateDetectionWork=new SeparateDetectionWork(*this, cascadeFilename);
+
     weightsPositionsSmoothing.push_back(1);
     weightsSizesSmoothing.push_back(0.5);
     weightsSizesSmoothing.push_back(0.3);
     weightsSizesSmoothing.push_back(0.2);
+
 }
 
 DetectionBasedTracker::~DetectionBasedTracker()
@@ -479,7 +479,7 @@ void DetectionBasedTracker::process(const Mat& imageGray)
 {
     CV_Assert(imageGray.type()==CV_8UC1);
 
-    if ( (!separateDetectionWork.empty()) && (!separateDetectionWork->isWorking()) ) {
+    if (!separateDetectionWork->isWorking()) {
         separateDetectionWork->run();
     }
 
@@ -488,18 +488,18 @@ void DetectionBasedTracker::process(const Mat& imageGray)
 
     {
         double delta_time_from_prev_call=1000.0 * (((double)(getTickCount()  - time_when_last_call_started)) / freq);
-        (void)(delta_time_from_prev_call);
         LOGD("DetectionBasedTracker::process: time from the previous call is %f ms", (double)delta_time_from_prev_call);
         time_when_last_call_started=getTickCount();
     }
 
     Mat imageDetect=imageGray;
 
+    int D = parameters.minObjectSize;
+    if (D < 1)
+        D=1;
+
     vector<Rect> rectsWhereRegions;
-    bool shouldHandleResult=false;
+    bool shouldHandleResult=separateDetectionWork->communicateWithDetectingThread(imageGray, rectsWhereRegions);
-    if (!separateDetectionWork.empty()) {
-        shouldHandleResult = separateDetectionWork->communicateWithDetectingThread(imageGray, rectsWhereRegions);
-    }
 
     if (shouldHandleResult) {
         LOGD("DetectionBasedTracker::process: get _rectsWhereRegions were got from resultDetect");
@@ -515,6 +515,7 @@ void DetectionBasedTracker::process(const Mat& imageGray)
                 continue;
             }
 
+
             // correction by speed of rectangle
             if (n > 1) {
                 Point2f center = centerRect(r);
@@ -571,38 +572,20 @@ void DetectionBasedTracker::getObjects(std::vector<Object>& result) const
         LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}", r.width, r.height, r.x, r.y, r.width, r.height);
     }
 }
-void DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
-{
-    result.clear();
-
-    for(size_t i=0; i < trackedObjects.size(); i++) {
-        ObjectStatus status;
-        Rect r=calcTrackedObjectPositionToShow(i, status);
-        result.push_back(ExtObject(trackedObjects[i].id, r, status));
-        LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}, status = %d", r.width, r.height, r.x, r.y, r.width, r.height, (int)status);
-    }
-}
 
 bool DetectionBasedTracker::run()
 {
-    if (!separateDetectionWork.empty()) {
     return separateDetectionWork->run();
 }
-    return false;
-}
 
 void DetectionBasedTracker::stop()
 {
-    if (!separateDetectionWork.empty()) {
     separateDetectionWork->stop();
 }
-}
 
 void DetectionBasedTracker::resetTracking()
 {
-    if (!separateDetectionWork.empty()) {
     separateDetectionWork->resetTracking();
-    }
     trackedObjects.clear();
 }
 
@@ -717,7 +700,6 @@ void DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObj
             int numpos=it->lastPositions.size();
             CV_Assert(numpos > 0);
             Rect r = it->lastPositions[numpos-1];
-            (void)(r);
             LOGD("DetectionBasedTracker::updateTrackedObjects: deleted object {%d, %d, %d x %d}",
                     r.x, r.y, r.width, r.height);
             it=trackedObjects.erase(it);
@@ -727,35 +709,18 @@ void DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObj
     }
 }
 
-int DetectionBasedTracker::addObject(const Rect& location)
-{
-    LOGD("DetectionBasedTracker::addObject: new object {%d, %d %dx%d}",location.x, location.y, location.width, location.height);
-    trackedObjects.push_back(TrackedObject(location));
-    int newId = trackedObjects.back().id;
-    LOGD("DetectionBasedTracker::addObject: newId = %d", newId);
-    return newId;
-}
-
 Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
-{
-    ObjectStatus status;
-    return calcTrackedObjectPositionToShow(i, status);
-}
-Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
 {
     if ( (i < 0) || (i >= (int)trackedObjects.size()) ) {
         LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: wrong i=%d", i);
-        status = WRONG_OBJECT;
         return Rect();
     }
     if (trackedObjects[i].numDetectedFrames <= innerParameters.numStepsToWaitBeforeFirstShow){
         LOGI("DetectionBasedTracker::calcTrackedObjectPositionToShow: trackedObjects[%d].numDetectedFrames=%d <= numStepsToWaitBeforeFirstShow=%d --- return empty Rect()",
                 i, trackedObjects[i].numDetectedFrames, innerParameters.numStepsToWaitBeforeFirstShow);
-        status = DETECTED_NOT_SHOWN_YET;
         return Rect();
     }
     if (trackedObjects[i].numFramesNotDetected > innerParameters.numStepsToShowWithoutDetecting) {
-        status = DETECTED_TEMPORARY_LOST;
         return Rect();
     }
 
@@ -764,7 +729,6 @@ Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus&
     int N=lastPositions.size();
     if (N<=0) {
         LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: no positions for i=%d", i);
-        status = WRONG_OBJECT;
         return Rect();
     }
 
@@ -823,7 +787,6 @@ Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus&
     Rect res(cvRound(tl.x), cvRound(tl.y), cvRound(w), cvRound(h));
     LOGD("DetectionBasedTracker::calcTrackedObjectPositionToShow: Result for i=%d: {%d, %d, %d x %d}", i, res.x, res.y, res.width, res.height);
 
-    status = DETECTED;
     return res;
 }
 
@@ -838,7 +801,8 @@ void DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector
         return;
     }
 
-    int d = cvRound(std::min(r.width, r.height) * innerParameters.coeffObjectSizeToTrack);
+    int d = std::min(r.width, r.height);
+    d = cvRound(d * innerParameters.coeffObjectSizeToTrack);
 
     vector<Rect> tmpobjects;
 
@@ -846,17 +810,17 @@ void DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector
     LOGD("DetectionBasedTracker::detectInRegion: img1.size()=%d x %d, d=%d",
             img1.size().width, img1.size().height, d);
 
-    cascadeForTracking->setMinObjectSize(Size(d, d));
+    int maxObjectSize = parameters.maxObjectSize;
-    cascadeForTracking->detect(img1, tmpobjects);
+    Size max_objectSize(maxObjectSize, maxObjectSize);
-            /*
+
-            detectMultiScale( img1, tmpobjects,
+    cascadeForTracking.detectMultiScale( img1, tmpobjects,
             parameters.scaleFactor, parameters.minNeighbors, 0
             |CV_HAAR_FIND_BIGGEST_OBJECT
             |CV_HAAR_SCALE_IMAGE
             ,
             Size(d,d),
             max_objectSize
-            );*/
+            );
 
     for(size_t i=0; i < tmpobjects.size(); i++) {
         Rect curres(tmpobjects[i].tl() + r1.tl(), tmpobjects[i].size());
@@ -866,23 +830,22 @@ void DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector
 
 bool DetectionBasedTracker::setParameters(const Parameters& params)
 {
-    if ( params.maxTrackLifetime < 0 )
+    if ( (params.minObjectSize <= 0)
+            || (params.maxObjectSize < 0)
+            || (params.scaleFactor <= 1.0)
+            || (params.maxTrackLifetime < 0) )
     {
         LOGE("DetectionBasedTracker::setParameters: ERROR: wrong parameters value");
         return false;
     }
 
-    if (!separateDetectionWork.empty()) {
     separateDetectionWork->lock();
-    }
     parameters=params;
-    if (!separateDetectionWork.empty()) {
     separateDetectionWork->unlock();
-    }
     return true;
 }
 
-const DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
+const DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters()
 {
     return parameters;
 }

samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp

@@ -18,53 +18,6 @@ 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.empty());
-    }
-
-    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.empty());
-        CV_Assert(!_trackingDetector.empty());
-
-        DetectionBasedTracker::Parameters DetectorParams;
-        tracker = new DetectionBasedTracker(mainDetector.ptr<DetectionBasedTracker::IDetector>(), trackingDetector.ptr<DetectionBasedTracker::IDetector>(), DetectorParams);
-    }
-};
-
 JNIEXPORT jlong JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeCreateObject
 (JNIEnv * jenv, jclass, jstring jFileName, jint faceSize)
 {
@@ -73,18 +26,12 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeC
     string stdFileName(jnamestr);
     jlong result = 0;
 
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeCreateObject");
-
     try
     {
-        cv::Ptr<CascadeDetectorAdapter> mainDetector = new CascadeDetectorAdapter(new CascadeClassifier(stdFileName));
+        DetectionBasedTracker::Parameters DetectorParams;
-        cv::Ptr<CascadeDetectorAdapter> trackingDetector = new CascadeDetectorAdapter(new CascadeClassifier(stdFileName));
-        result = (jlong)new DetectorAgregator(mainDetector, trackingDetector);
         if (faceSize > 0)
-        {
+            DetectorParams.minObjectSize = faceSize;
-            mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+        result = (jlong)new DetectionBasedTracker(stdFileName, DetectorParams);
-            //trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
-        }
     }
     catch(cv::Exception e)
     {
@@ -98,7 +45,7 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeC
     {
         LOGD("nativeCreateObject catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeCreateObject(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
         return 0;
     }
 
@@ -109,14 +56,13 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeC
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDestroyObject
 (JNIEnv * jenv, jclass, jlong thiz)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDestroyObject");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDestroyObject enter");
-
     try
     {
         if(thiz != 0)
         {
-            ((DetectorAgregator*)thiz)->tracker->stop();
+            ((DetectionBasedTracker*)thiz)->stop();
-            delete (DetectorAgregator*)thiz;
+            delete (DetectionBasedTracker*)thiz;
         }
     }
     catch(cv::Exception e)
@@ -131,7 +77,7 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDe
     {
         LOGD("nativeDestroyObject catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDestroyObject(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
     }
     LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDestroyObject exit");
 }
@@ -139,11 +85,10 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDe
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart
 (JNIEnv * jenv, jclass, jlong thiz)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart enter");
-
     try
     {
-        ((DetectorAgregator*)thiz)->tracker->run();
+        ((DetectionBasedTracker*)thiz)->run();
     }
     catch(cv::Exception e)
     {
@@ -157,7 +102,7 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSt
     {
         LOGD("nativeStart catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
     }
     LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart exit");
 }
@@ -165,11 +110,10 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSt
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop
 (JNIEnv * jenv, jclass, jlong thiz)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop enter");
-
     try
     {
-        ((DetectorAgregator*)thiz)->tracker->stop();
+        ((DetectionBasedTracker*)thiz)->stop();
     }
     catch(cv::Exception e)
     {
@@ -183,7 +127,7 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSt
     {
         LOGD("nativeStop catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
     }
     LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop exit");
 }
@@ -191,14 +135,15 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSt
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize
 (JNIEnv * jenv, jclass, jlong thiz, jint faceSize)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize -- BEGIN");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize enter");
-
     try
     {
         if (faceSize > 0)
         {
-            ((DetectorAgregator*)thiz)->mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+            DetectionBasedTracker::Parameters DetectorParams = \
-            //((DetectorAgregator*)thiz)->trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+            ((DetectionBasedTracker*)thiz)->getParameters();
+            DetectorParams.minObjectSize = faceSize;
+            ((DetectionBasedTracker*)thiz)->setParameters(DetectorParams);
         }
     }
     catch(cv::Exception e)
@@ -213,23 +158,22 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSe
     {
         LOGD("nativeSetFaceSize catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
     }
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize -- END");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeSetFaceSize exit");
 }
 
 
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect
 (JNIEnv * jenv, jclass, jlong thiz, jlong imageGray, jlong faces)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect enter");
-
     try
     {
         vector<Rect> RectFaces;
-        ((DetectorAgregator*)thiz)->tracker->process(*((Mat*)imageGray));
+        ((DetectionBasedTracker*)thiz)->process(*((Mat*)imageGray));
-        ((DetectorAgregator*)thiz)->tracker->getObjects(RectFaces);
+        ((DetectionBasedTracker*)thiz)->getObjects(RectFaces);
-        *((Mat*)faces) = Mat(RectFaces, true);
+        vector_Rect_to_Mat(RectFaces, *((Mat*)faces));
     }
     catch(cv::Exception e)
     {
@@ -243,7 +187,7 @@ JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDe
     {
         LOGD("nativeDetect catched unknown exception");
         jclass je = jenv->FindClass("java/lang/Exception");
-        jenv->ThrowNew(je, "Unknown exception in JNI code {Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect(...)}");
+        jenv->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
     }
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect END");
+    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeDetect exit");
 }