Move objdetect HaarCascadeClassifier and HOGDescriptor to contrib xobjdetect (#3692)

* Move objdetect parts to contrib

* Move objdetect parts to contrib

* Fix errors from CI build.

* Minor fixes.

Author: kaingwade

modules/cudalegacy/CMakeLists.txt

@@ -9,4 +9,4 @@ if(ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
   ocv_module_include_directories(${CUDAToolkit_INCLUDE_DIRS})
 endif()
 ocv_define_module(cudalegacy opencv_core opencv_video
-  OPTIONAL opencv_objdetect opencv_imgproc opencv_3d opencv_stereo opencv_calib opencv_cudaarithm opencv_cudafilters opencv_cudaimgproc)
+  OPTIONAL opencv_objdetect opencv_xobjdetect opencv_imgproc opencv_3d opencv_stereo opencv_calib opencv_cudaarithm opencv_cudafilters opencv_cudaimgproc)

modules/cudalegacy/src/NCV.cpp

@@ -737,12 +737,12 @@ struct RectConvert
 
 static void groupRectangles(std::vector<NcvRect32u> &hypotheses, int groupThreshold, double eps, std::vector<Ncv32u> *weights)
 {
-#ifndef HAVE_OPENCV_OBJDETECT
+#ifndef HAVE_OPENCV_XOBJDETECT
     CV_UNUSED(hypotheses);
     CV_UNUSED(groupThreshold);
     CV_UNUSED(eps);
     CV_UNUSED(weights);
-    CV_Error(cv::Error::StsNotImplemented, "This functionality requires objdetect module");
+    CV_Error(cv::Error::StsNotImplemented, "This functionality requires xobjdetect module");
 #else
     std::vector<cv::Rect> rects(hypotheses.size());
     std::transform(hypotheses.begin(), hypotheses.end(), rects.begin(), RectConvert());

modules/cudalegacy/src/cuda/NCVHaarObjectDetection.cu

@@ -64,8 +64,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_OBJDETECT
-#  include "opencv2/objdetect.hpp"
+#ifdef HAVE_OPENCV_XOBJDETECT
+#  include "opencv2/xobjdetect.hpp"
 //#  include "opencv2/objdetect/objdetect_c.h"
 #endif
 
@@ -1843,16 +1843,16 @@ static NCVStatus loadFromXML(const cv::String &filename,
                       std::vector<HaarClassifierNode128> &haarClassifierNodes,
                       std::vector<HaarFeature64> &haarFeatures)
 {
-    const char *CUDA_CC_SIZE = "size";
-    const char *CUDA_CC_STAGES = "stages";
-    const char *CUDA_CC_STAGE_THRESHOLD = "stage_threshold";
-    const char *CUDA_CC_TREES = "trees";
-    const char *CUDA_CC_FEATURE = "feature";
-    const char *CUDA_CC_RECT = "rects";
-    const char *CUDA_CC_TILTED = "tilted";
-    const char *CUDA_CC_THRESHOLD = "threshold";
+    const char *CUDA_CC_SIZE = "size";
+    const char *CUDA_CC_STAGES = "stages";
+    const char *CUDA_CC_STAGE_THRESHOLD = "stage_threshold";
+    const char *CUDA_CC_TREES = "trees";
+    const char *CUDA_CC_FEATURE = "feature";
+    const char *CUDA_CC_RECT = "rects";
+    const char *CUDA_CC_TILTED = "tilted";
+    const char *CUDA_CC_THRESHOLD = "threshold";
     const char *CUDA_CC_LEFT_VAL = "left_val";
-    const char *CUDA_CC_RIGHT_VAL = "right_val";
+    const char *CUDA_CC_RIGHT_VAL = "right_val";
     const char *CUDA_CC_LEFT_NODE = "left_node";
     const char *CUDA_CC_RIGHT_NODE = "right_node";
 
@@ -1873,60 +1873,60 @@ static NCVStatus loadFromXML(const cv::String &filename,
     haarClassifierNodes.resize(0);
     haarFeatures.resize(0);
 
-    cv::FileStorage fs(filename, cv::FileStorage::READ | cv::FileStorage::FORMAT_XML);
-
-    if (!fs.isOpened())
+    cv::FileStorage fs(filename, cv::FileStorage::READ | cv::FileStorage::FORMAT_XML);
+
+    if (!fs.isOpened())
         return NCV_FILE_ERROR;
 
-    const cv::FileNode &root = fs.getFirstTopLevelNode();
+    const cv::FileNode &root = fs.getFirstTopLevelNode();
     const cv::FileNode &fnSize = root[CUDA_CC_SIZE];
 
     // collect the cascade classifier window size
     haar.ClassifierSize.width = (int)fnSize[CUDA_CC_SIZE_W];
     haar.ClassifierSize.height = (int)fnSize[CUDA_CC_SIZE_H];
     CV_Assert(haar.ClassifierSize.height > 0 && haar.ClassifierSize.width > 0);
 
-    const cv::FileNode &fnStages = root[CUDA_CC_STAGES];
+    const cv::FileNode &fnStages = root[CUDA_CC_STAGES];
     cv::FileNodeIterator it = fnStages.begin(), it_end = fnStages.end();
 
-    for (; it != it_end; ++it) // by stages
-    {
-        cv::FileNode fnStage = *it;
+    for (; it != it_end; ++it) // by stages
+    {
+        cv::FileNode fnStage = *it;
         HaarStage64 curStage;
 
-        curStage.setStartClassifierRootNodeOffset(static_cast<Ncv32u>(haarClassifierNodes.size()));
+        curStage.setStartClassifierRootNodeOffset(static_cast<Ncv32u>(haarClassifierNodes.size()));
         curStage.setStageThreshold((float)fnStage[CUDA_CC_STAGE_THRESHOLD]);
 
-        // iterate over the trees
-        const cv::FileNode &fnTrees = fnStage[CUDA_CC_TREES];
-        cv::FileNodeIterator it1 = fnTrees.begin(), it1_end = fnTrees.end();
-
-        for (; it1 != it1_end; ++it1) // by trees
-        {
-            cv::FileNode tree = *it1;
-            Ncv32u nodeId = (size_t)0;
-            HaarClassifierNode128 curNode;
-
-            curNode.setThreshold((float)tree[0][CUDA_CC_THRESHOLD]);
-
-            NcvBool bIsLeftNodeLeaf = false;
-            NcvBool bIsRightNodeLeaf = false;
-
+        // iterate over the trees
+        const cv::FileNode &fnTrees = fnStage[CUDA_CC_TREES];
+        cv::FileNodeIterator it1 = fnTrees.begin(), it1_end = fnTrees.end();
+
+        for (; it1 != it1_end; ++it1) // by trees
+        {
+            cv::FileNode tree = *it1;
+            Ncv32u nodeId = (size_t)0;
+            HaarClassifierNode128 curNode;
+
+            curNode.setThreshold((float)tree[0][CUDA_CC_THRESHOLD]);
+
+            NcvBool bIsLeftNodeLeaf = false;
+            NcvBool bIsRightNodeLeaf = false;
+
             HaarClassifierNodeDescriptor32 nodeLeft;
 
             cv::FileNode leftNode = tree[0][CUDA_CC_LEFT_NODE];
 
             if (leftNode.fs == NULL)
             {
-                Ncv32f leftVal = tree[0][CUDA_CC_LEFT_VAL];
-                ncvStat = nodeLeft.create(leftVal);
+                Ncv32f leftVal = tree[0][CUDA_CC_LEFT_VAL];
+                ncvStat = nodeLeft.create(leftVal);
                 ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
                 bIsLeftNodeLeaf = true;
             }
             else
             {
-                Ncv32u leftNodeOffset = (int)tree[0][CUDA_CC_LEFT_NODE];
-                nodeLeft.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1));
+                Ncv32u leftNodeOffset = (int)tree[0][CUDA_CC_LEFT_NODE];
+                nodeLeft.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1));
                 haar.bHasStumpsOnly = false;
             }
 
@@ -1937,15 +1937,15 @@ static NCVStatus loadFromXML(const cv::String &filename,
 
             if (rightNode.fs == NULL)
             {
-                Ncv32f rightVal = tree[0][CUDA_CC_RIGHT_VAL];
-                ncvStat = nodeRight.create(rightVal);
+                Ncv32f rightVal = tree[0][CUDA_CC_RIGHT_VAL];
+                ncvStat = nodeRight.create(rightVal);
                 ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
                 bIsRightNodeLeaf = true;
             }
             else
             {
-                Ncv32u rightNodeOffset = (int)tree[0][CUDA_CC_RIGHT_NODE];
-                nodeRight.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1));
+                Ncv32u rightNodeOffset = (int)tree[0][CUDA_CC_RIGHT_NODE];
+                nodeRight.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1));
                 haar.bHasStumpsOnly = false;
             }
 
@@ -1955,9 +1955,9 @@ static NCVStatus loadFromXML(const cv::String &filename,
             Ncv32u tiltedVal = (int)fnFeature[CUDA_CC_TILTED];
             haar.bNeedsTiltedII = (tiltedVal != 0);
 
-            cv::FileNodeIterator it2 = fnFeature[CUDA_CC_RECT].begin(), it2_end = fnFeature[CUDA_CC_RECT].end();
+            cv::FileNodeIterator it2 = fnFeature[CUDA_CC_RECT].begin(), it2_end = fnFeature[CUDA_CC_RECT].end();
 
-            Ncv32u featureId = 0;
+            Ncv32u featureId = 0;
             for (; it2 != it2_end; ++it2) // by feature
             {
                 cv::FileNode rect = *it2;

modules/cudalegacy/src/precomp.hpp

@@ -63,6 +63,10 @@
 #  include "opencv2/objdetect.hpp"
 #endif
 
+#ifdef HAVE_OPENCV_XOBJDETECT
+#  include "opencv2/xobjdetect.hpp"
+#endif
+
 #ifdef HAVE_OPENCV_3D
 #  include "opencv2/3d.hpp"
 #endif

modules/cudaobjdetect/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "CUDA-accelerated Object Detection")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations -Wshadow -Wstrict-aliasing)
 
-ocv_define_module(cudaobjdetect opencv_objdetect opencv_cudaarithm opencv_cudawarping OPTIONAL opencv_cudalegacy WRAP python)
+ocv_define_module(cudaobjdetect opencv_objdetect opencv_xobjdetect opencv_cudaarithm opencv_cudawarping OPTIONAL opencv_cudalegacy WRAP python)

modules/cudaobjdetect/include/opencv2/cudaobjdetect.hpp

@@ -48,7 +48,7 @@
 #endif
 
 #include "opencv2/core/cuda.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 /**
   @addtogroup cuda
@@ -70,11 +70,11 @@ namespace cv { namespace cuda {
 
 @note
     -   An example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/cpp/peopledetect.cpp
+        xobjdetect_module/samples/peopledetect.cpp
     -   A CUDA example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/gpu/hog.cpp
+        xobjdetect_module/samples/gpu/hog.cpp
     -   (Python) An example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/python/peopledetect.py
+        xobjdetect_module/samples/python/peopledetect.py
  */
 class CV_EXPORTS_W HOG : public Algorithm
 {
@@ -222,8 +222,8 @@ class CV_EXPORTS_W HOG : public Algorithm
 /** @brief Cascade classifier class used for object detection. Supports HAAR and LBP cascades. :
 
 @note
-   -   A cascade classifier example can be found at
-        opencv_source_code/samples/gpu/cascadeclassifier.cpp
+    -   A cascade classifier example can be found at
+        xobjdetect_module/samples/gpu/cascadeclassifier.cpp
     -   A Nvidea API specific cascade classifier example can be found at
         opencv_source_code/samples/gpu/cascadeclassifier_nvidia_api.cpp
  */

modules/cudaobjdetect/perf/perf_precomp.hpp

@@ -46,7 +46,7 @@
 #include "opencv2/ts/cuda_perf.hpp"
 
 #include "opencv2/cudaobjdetect.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 namespace opencv_test { using namespace perf; }
 

modules/cudaobjdetect/src/precomp.hpp

@@ -48,7 +48,7 @@
 #include "opencv2/cudaobjdetect.hpp"
 #include "opencv2/cudaarithm.hpp"
 #include "opencv2/cudawarping.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 #include "opencv2/core/private.cuda.hpp"
 #include "opencv2/core/utility.hpp"

modules/cudaobjdetect/test/test_precomp.hpp

@@ -48,7 +48,7 @@
 #include "opencv2/ts/cuda_test.hpp"
 
 #include "opencv2/cudaobjdetect.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 #include "cvconfig.h"
 

modules/face/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(the_description "Face recognition etc")
 ocv_define_module(face opencv_core
     opencv_imgproc
-    opencv_objdetect
+    opencv_xobjdetect
     opencv_3d   # estimateAffinePartial2D() (trainFacemark)
     opencv_photo     # seamlessClone() (face_swap sample)
     WRAP python java objc