Fix the problem of haar caused by merge

Author: bitwangyaoyao

modules/ocl/doc/object_detection.rst

@@ -12,31 +12,30 @@ Cascade classifier class used for object detection. Supports HAAR cascade classi
     class CV_EXPORTS OclCascadeClassifier : public CascadeClassifier
     {
     public:
-          OclCascadeClassifier() {};
-          ~OclCascadeClassifier() {};
-           CvSeq *oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage,
-                                      double scaleFactor,int minNeighbors,
-                                      int flags, CvSize minSize = cvSize(0, 0),
-                                      CvSize maxSize = cvSize(0, 0));
+            void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
+                                              double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
+                                              Size minSize = Size(), Size maxSize = Size());
     };
 
 ocl::OclCascadeClassifier::oclHaarDetectObjects
 ------------------------------------------------------
-Returns the detected objects by a list of rectangles
+Detects objects of different sizes in the input image.
 
-.. ocv:function:: CvSeq* ocl::OclCascadeClassifier::oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0))
+.. ocv:function:: void ocl::OclCascadeClassifier::detectMultiScale(oclMat &image, std::vector<cv::Rect>& faces, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size())
 
     :param image:  Matrix of type CV_8U containing an image where objects should be detected.
 
-    :param imageobjectsBuff: Buffer to store detected objects (rectangles). If it is empty, it is allocated with the defaultsize. If not empty, the function searches not more than N  objects, where N = sizeof(objectsBufers data)/sizeof(cv::Rect).
+    :param faces: Vector of rectangles where each rectangle contains the detected object.
 
     :param scaleFactor: Parameter specifying how much the image size is reduced at each image scale.
 
     :param minNeighbors: Parameter specifying how many neighbors each candidate rectangle should have to retain it.
 
     :param minSize: Minimum possible object size. Objects smaller than that are ignored.
 
-Detects objects of different sizes in the input image,only tested for face detection now. The function returns the number of detected objects.
+    :param maxSize: Maximum possible object size. Objects larger than that are ignored.
+
+The function provides a very similar interface with that in CascadeClassifier class, except using oclMat as input image.
 
 ocl::MatchTemplateBuf
 ---------------------

modules/ocl/include/opencv2/ocl.hpp

@@ -856,59 +856,13 @@ namespace cv
         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////CascadeClassifier//////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if 0
         class CV_EXPORTS OclCascadeClassifier : public  cv::CascadeClassifier
         {
         public:
-            OclCascadeClassifier() {};
-            ~OclCascadeClassifier() {};
-
-            CvSeq* oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,
-                                        int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0));
-        };
-#endif
-
-#if 0
-        class CV_EXPORTS OclCascadeClassifierBuf : public  cv::CascadeClassifier
-        {
-        public:
-            OclCascadeClassifierBuf() :
-                m_flags(0), initialized(false), m_scaleFactor(0), buffers(NULL) {}
-
-            ~OclCascadeClassifierBuf() { release(); }
-
             void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
                                   double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
                                   Size minSize = Size(), Size maxSize = Size());
-            void release();
-
-        private:
-            void Init(const int rows, const int cols, double scaleFactor, int flags,
-                      const int outputsz, const size_t localThreads[],
-                      Size minSize, Size maxSize);
-            void CreateBaseBufs(const int datasize, const int totalclassifier, const int flags, const int outputsz);
-            void CreateFactorRelatedBufs(const int rows, const int cols, const int flags,
-                                         const double scaleFactor, const size_t localThreads[],
-                                         Size minSize, Size maxSize);
-            void GenResult(CV_OUT std::vector<cv::Rect>& faces, const std::vector<cv::Rect> &rectList, const std::vector<int> &rweights);
-
-            int m_rows;
-            int m_cols;
-            int m_flags;
-            int m_loopcount;
-            int m_nodenum;
-            bool findBiggestObject;
-            bool initialized;
-            double m_scaleFactor;
-            Size m_minSize;
-            Size m_maxSize;
-            std::vector<Size> sizev;
-            std::vector<float> scalev;
-            oclMat gimg1, gsum, gsqsum;
-            void * buffers;
         };
-#endif
 
         /////////////////////////////// Pyramid /////////////////////////////////////
         CV_EXPORTS void pyrDown(const oclMat &src, oclMat &dst);

modules/ocl/perf/perf_haar.cpp

@@ -44,47 +44,8 @@
 //
 //M*/
 #include "precomp.hpp"
-
-#if 0
-
 ///////////// Haar ////////////////////////
-namespace cv
-{
-namespace ocl
-{
-
-struct getRect
-{
-    Rect operator()(const CvAvgComp &e) const
-    {
-        return e.rect;
-    }
-};
 
-class CascadeClassifier_GPU : public OclCascadeClassifier
-{
-public:
-    void detectMultiScale(oclMat &image,
-                          CV_OUT std::vector<cv::Rect>& faces,
-                          double scaleFactor = 1.1,
-                          int minNeighbors = 3, int flags = 0,
-                          Size minSize = Size(),
-                          Size maxSize = Size())
-    {
-        (void)maxSize;
-        MemStorage storage(cvCreateMemStorage(0));
-        //CvMat img=image;
-        CvSeq *objs = oclHaarDetectObjects(image, storage, scaleFactor, minNeighbors, flags, minSize);
-        vector<CvAvgComp> vecAvgComp;
-        Seq<CvAvgComp>(objs).copyTo(vecAvgComp);
-        faces.resize(vecAvgComp.size());
-        std::transform(vecAvgComp.begin(), vecAvgComp.end(), faces.begin(), getRect());
-    }
-
-};
-
-}
-}
 PERFTEST(Haar)
 {
     Mat img = imread(abspath("basketball1.png"), IMREAD_GRAYSCALE);
@@ -106,12 +67,12 @@ PERFTEST(Haar)
     SUBTEST << img.cols << "x" << img.rows << "; scale image";
     CPU_ON;
     faceCascadeCPU.detectMultiScale(img, faces,
-                                    1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
+                                    1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
     CPU_OFF;
 
 
     vector<Rect> oclfaces;
-    ocl::CascadeClassifier_GPU faceCascade;
+    ocl::OclCascadeClassifier faceCascade;
 
     if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
     {
@@ -122,7 +83,7 @@ PERFTEST(Haar)
 
     WARMUP_ON;
     faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
+                                 1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
     WARMUP_OFF;
 
     if(faces.size() == oclfaces.size())
@@ -134,14 +95,12 @@ PERFTEST(Haar)
 
     GPU_ON;
     faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
+                                 1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
     GPU_OFF;
 
     GPU_FULL_ON;
     d_img.upload(img);
     faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
+                                 1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
     GPU_FULL_OFF;
-}
-
-#endif
+}