Reverted r8721 and r8725 (issue #2080)

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

@@ -7,73 +7,22 @@
 
 #include <vector>
 
-namespace cv
-{
 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
-        {
-            public:
-                IDetector():
-                    minObjSize(96, 96),
-                    maxObjSize(INT_MAX, INT_MAX),
-                    minNeighbours(2),
-                    scaleFactor(1.1f)
-                {}
-
-                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;
-                }
-                virtual ~IDetector() {}
-
-            protected:
-                cv::Size minObjSize;
-                cv::Size maxObjSize;
-                int minNeighbours;
-                float scaleFactor;
-        };
-
-        DetectionBasedTracker(cv::Ptr<IDetector> MainDetector, cv::Ptr<IDetector> TrackingDetector, const Parameters& params);
+        DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params);
         virtual ~DetectionBasedTracker();
 
         virtual bool run();
@@ -95,6 +44,7 @@ class DetectionBasedTracker
         cv::Ptr<SeparateDetectionWork> separateDetectionWork;
         friend void* workcycleObjectDetectorFunction(void* p);
 
+
         struct InnerParameters
         {
             int numLastPositionsToTrack;
@@ -140,11 +90,13 @@ 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;
         void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
 };
-} //end of cv namespace
+
 #endif
+

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)
 {
@@ -72,18 +25,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));
-	cv::Ptr<CascadeDetectorAdapter> trackingDetector = new CascadeDetectorAdapter(new CascadeClassifier(stdFileName));
-	result = (jlong)new DetectorAgregator(mainDetector, trackingDetector);
+    DetectionBasedTracker::Parameters DetectorParams;
     if (faceSize > 0)
-	{
-	    mainDetector->setMinObjectSize(Size(faceSize, faceSize));
-	    //trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
-	}
+        DetectorParams.minObjectSize = faceSize;
+    result = (jlong)new DetectionBasedTracker(stdFileName, DetectorParams);
     }
     catch(cv::Exception e)
     {
@@ -97,7 +44,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;
     }
 
@@ -107,12 +54,10 @@ 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");
-    
     try
     {
-	((DetectorAgregator*)thiz)->tracker->stop();
-	delete (DetectorAgregator*)thiz;
+    ((DetectionBasedTracker*)thiz)->stop();
+    delete (DetectionBasedTracker*)thiz;
     }
     catch(cv::Exception e)
     {
@@ -126,18 +71,16 @@ 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__()}");
     }
 }
 
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart
 (JNIEnv * jenv, jclass, jlong thiz)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStart");
-    
     try
     {
-	((DetectorAgregator*)thiz)->tracker->run();
+    ((DetectionBasedTracker*)thiz)->run();
     }
     catch(cv::Exception e)
     {
@@ -151,18 +94,16 @@ 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__()}");
     }
 }
 
 JNIEXPORT void JNICALL Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop
 (JNIEnv * jenv, jclass, jlong thiz)
 {
-    LOGD("Java_org_opencv_samples_fd_DetectionBasedTracker_nativeStop");
-    
     try
     {
-	((DetectorAgregator*)thiz)->tracker->stop();
+    ((DetectionBasedTracker*)thiz)->stop();
     }
     catch(cv::Exception e)
     {
@@ -176,22 +117,23 @@ 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__()}");
     }
 }
 
 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");
-    
     try
     {
     if (faceSize > 0)
     {
-	    ((DetectorAgregator*)thiz)->mainDetector->setMinObjectSize(Size(faceSize, faceSize));
-	    //((DetectorAgregator*)thiz)->trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+        DetectionBasedTracker::Parameters DetectorParams = \
+        ((DetectionBasedTracker*)thiz)->getParameters();
+        DetectorParams.minObjectSize = faceSize;
+        ((DetectionBasedTracker*)thiz)->setParameters(DetectorParams);
     }
+
     }
     catch(cv::Exception e)
     {
@@ -205,23 +147,20 @@ 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");
 }
 
 
 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");
-    
     try
     {
     vector<Rect> RectFaces;
-	((DetectorAgregator*)thiz)->tracker->process(*((Mat*)imageGray));
-	((DetectorAgregator*)thiz)->tracker->getObjects(RectFaces);
-	*((Mat*)faces) = Mat(RectFaces, true);
+    ((DetectionBasedTracker*)thiz)->process(*((Mat*)imageGray));
+    ((DetectionBasedTracker*)thiz)->getObjects(RectFaces);
+    vector_Rect_to_Mat(RectFaces, *((Mat*)faces));
     }
     catch(cv::Exception e)
     {
@@ -235,7 +174,6 @@ 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");
 }
\ No newline at end of file

samples/cpp/CMakeLists.txt

@@ -3,7 +3,7 @@
 #
 # ----------------------------------------------------------------------------
 
-SET(OPENCV_CPP_SAMPLES_REQUIRED_DEPS opencv_core_vision_api opencv_core opencv_flann opencv_imgproc
+SET(OPENCV_CPP_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc
     opencv_highgui opencv_ml opencv_video opencv_objdetect opencv_photo opencv_nonfree
     opencv_features2d opencv_calib3d opencv_legacy opencv_contrib opencv_stitching opencv_videostab)
 

samples/cpp/core_vision_tracking_image.cpp

-#include <opencv2/core/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
-#include <opencv2/highgui/highgui.hpp>  // OpenCV window I/O
-#include <opencv2/core_vision_api/tracker.hpp>
-
-#include <stdio.h>
-#include <string>
-#include <vector>
-
-using namespace std;
-using namespace cv;
-
-const string WindowName = "Face Detection example";
-const Scalar RectColor = CV_RGB(0,255,0);
-
-int main()
-{
-    namedWindow(WindowName);
-    cv::moveWindow(WindowName, 100, 100);
-
-    Mat Viewport;
-    Mat ReferenceFrame = imread("board.jpg");
-    if (ReferenceFrame.empty())
-    {
-        printf("Error: Cannot load input image\n");
-        return 1;
-    }
-
-    cv::Ptr<nv::Tracker> tracker = nv::Algorithm::create<nv::Tracker>("nv::Tracker::OpticalFlow");
-
-    tracker->initialize();
-
-    // First frame for initialization
-    tracker->feed(ReferenceFrame);
-
-    nv::Tracker::TrackedObjectHandler obj = tracker->addObject(cv::Rect(100,100, 200, 200));
-
-    while(true)
-    {
-        tracker->feed(ReferenceFrame);
-
-        if (obj->getStatus() == nv::Tracker::LOST_STATUS)
-            break;
-
-        cv::Rect currentLocation = obj->getLocation();
-
-        ReferenceFrame.copyTo(Viewport);
-        rectangle(Viewport, currentLocation, RectColor);
-
-        imshow(WindowName, Viewport);
-
-        if (cvWaitKey(30) >= 0) break;
-    }
-
-    return 0;
-}

samples/cpp/dbt_face_detection.cpp

-#if 0 //defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID)
-
-#include <opencv2/imgproc/imgproc.hpp>  // Gaussian Blur
-#include <opencv2/core/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
-#include <opencv2/highgui/highgui.hpp>  // OpenCV window I/O
-#include <opencv2/features2d/features2d.hpp>
-#include <opencv2/contrib/detection_based_tracker.hpp>
-
-#include <stdio.h>
-#include <string>
-#include <vector>
-
-using namespace std;
-using namespace cv;
-
-const string WindowName = "Face Detection example";
-
-class CascadeDetectorAdapter: public DetectionBasedTracker::IDetector
-{
-    public:
-        CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):
-            IDetector(),
-            Detector(detector)
-        {
-            CV_Assert(!detector.empty());
-        }
-
-        void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects)
-        {
-            Detector->detectMultiScale(Image, objects, scaleFactor, minNeighbours, 0, minObjSize, maxObjSize);
-        }
-
-        virtual ~CascadeDetectorAdapter()
-        {}
-
-    private:
-        CascadeDetectorAdapter();
-        cv::Ptr<cv::CascadeClassifier> Detector;
- };
-
-int main(int argc, char* argv[])
-{
-    namedWindow(WindowName);
-
-    VideoCapture VideoStream(0);
-
-    if (!VideoStream.isOpened())
-    {
-        printf("Error: Cannot open video stream from camera\n");
-        return 1;
-    }
-
-    std::string cascadeFrontalfilename = "../../data/lbpcascades/lbpcascade_frontalface.xml";
-    cv::Ptr<cv::CascadeClassifier> cascade = new cv::CascadeClassifier(cascadeFrontalfilename);
-    cv::Ptr<DetectionBasedTracker::IDetector> MainDetector = new CascadeDetectorAdapter(cascade);
-
-    cascade = new cv::CascadeClassifier(cascadeFrontalfilename);
-    cv::Ptr<DetectionBasedTracker::IDetector> TrackingDetector = new CascadeDetectorAdapter(cascade);
-
-    DetectionBasedTracker::Parameters params;
-    DetectionBasedTracker Detector(MainDetector, TrackingDetector, params);
-
-    if (!Detector.run())
-    {
-        printf("Error: Detector initialization failed\n");
-        return 2;
-    }
-
-    Mat ReferenceFrame;
-    Mat GrayFrame;
-    vector<Rect> Faces;
-
-    while(true)
-    {
-        VideoStream >> ReferenceFrame;
-        cvtColor(ReferenceFrame, GrayFrame, COLOR_RGB2GRAY);
-        Detector.process(GrayFrame);
-        Detector.getObjects(Faces);
-
-        for (size_t i = 0; i < Faces.size(); i++)
-        {
-            rectangle(ReferenceFrame, Faces[i], CV_RGB(0,255,0));
-        }
-
-        imshow(WindowName, ReferenceFrame);
-
-        if (cvWaitKey(30) >= 0) break;
-    }
-
-    Detector.stop();
-
-    return 0;
-}
-
-#else
-
-#include <stdio.h>
-int main()
-{
-    printf("This sample works for UNIX or ANDROID only\n");
-    return 0;
-}
-
-#endif

samples/cpp/detection_based_tracker_sample.cpp

@@ -43,6 +43,8 @@
 #define LOGE(...) do{} while(0)
 #endif
 
+
+
 using namespace cv;
 using namespace std;
 
@@ -61,31 +63,9 @@ static void usage()
     LOGE0("\t       (e.g.\"opencv/data/lbpcascades/lbpcascade_frontalface.xml\" ");
 }
 
-class CascadeDetectorAdapter: public DetectionBasedTracker::IDetector
-{
-    public:
-        CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):
-            Detector(detector)
-        {
-            CV_Assert(!detector.empty());
-        }
-
-        void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects)
-        {
-            Detector->detectMultiScale(Image, objects, 1.1, 3, 0, minObjSize, maxObjSize);
-        }
-        virtual ~CascadeDetectorAdapter()
-        {}
-
-    private:
-        CascadeDetectorAdapter();
-        cv::Ptr<cv::CascadeClassifier> Detector;
- };
-
 static int test_FaceDetector(int argc, char *argv[])
 {
-    if (argc < 4)
-    {
+    if (argc < 4) {
         usage();
         return -1;
     }
@@ -100,14 +80,12 @@ static int test_FaceDetector(int argc, char *argv[])
     vector<Mat> images;
     {
         char filename[256];
-        for(int n=1; ; n++)
-        {
+        for(int n=1; ; n++) {
             snprintf(filename, sizeof(filename), filepattern, n);
             LOGD("filename='%s'", filename);
             Mat m0;
             m0=imread(filename);
-            if (m0.empty())
-            {
+            if (m0.empty()) {
                 LOGI0("Cannot read the file --- break");
                 break;
             }
@@ -116,15 +94,10 @@ static int test_FaceDetector(int argc, char *argv[])
         LOGD("read %d images", (int)images.size());
     }
 
+    DetectionBasedTracker::Parameters params;
     std::string cascadeFrontalfilename=cascadefile;
-    cv::Ptr<cv::CascadeClassifier> cascade = new cv::CascadeClassifier(cascadeFrontalfilename);
-    cv::Ptr<DetectionBasedTracker::IDetector> MainDetector = new CascadeDetectorAdapter(cascade);
 
-    cascade = new cv::CascadeClassifier(cascadeFrontalfilename);
-    cv::Ptr<DetectionBasedTracker::IDetector> TrackingDetector = new CascadeDetectorAdapter(cascade);
-
-    DetectionBasedTracker::Parameters params;
-    DetectionBasedTracker fd(MainDetector, TrackingDetector, params);
+    DetectionBasedTracker fd(cascadeFrontalfilename, params);
 
     fd.run();
 
@@ -135,13 +108,12 @@ static int test_FaceDetector(int argc, char *argv[])
     double freq=getTickFrequency();
 
     int num_images=images.size();
-    for(int n=1; n <= num_images; n++)
-    {
+    for(int n=1; n <= num_images; n++) {
         int64 tcur=getTickCount();
         int64 dt=tcur-tprev;
         tprev=tcur;
         double t_ms=((double)dt)/freq * 1000.0;
-        LOGD("\n\nSTEP n=%d        from prev step %f ms\n", n, t_ms);
+        LOGD("\n\nSTEP n=%d        from prev step %f ms\n\n", n, t_ms);
         m=images[n-1];
         CV_Assert(! m.empty());
         cvtColor(m, gray, CV_BGR2GRAY);
@@ -151,8 +123,11 @@ static int test_FaceDetector(int argc, char *argv[])
         vector<Rect> result;
         fd.getObjects(result);
 
-        for(size_t i=0; i < result.size(); i++)
-        {
+
+
+
+
+        for(size_t i=0; i < result.size(); i++) {
             Rect r=result[i];
             CV_Assert(r.area() > 0);
             Point tl=r.tl();
@@ -161,21 +136,23 @@ static int test_FaceDetector(int argc, char *argv[])
             rectangle(m, tl, br, color, 3);
         }
     }
-
-    char outfilename[256];
-    for(int n=1; n <= num_images; n++)
     {
+        char outfilename[256];
+        for(int n=1; n <= num_images; n++) {
             snprintf(outfilename, sizeof(outfilename), outfilepattern, n);
             LOGD("outfilename='%s'", outfilename);
             m=images[n-1];
             imwrite(outfilename, m);
         }
+    }
 
     fd.stop();
 
     return 0;
 }
 
+
+
 int main(int argc, char *argv[])
 {
     return test_FaceDetector(argc, argv);