Backport C-API cleanup (imgproc) from 5.x

Author: mshabunin

doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.markdown

@@ -204,9 +204,9 @@ receives three arguments:
 
     We can choose any of three shapes for our kernel:
 
-    -   Rectangular box: CV_SHAPE_RECT
-    -   Cross: CV_SHAPE_CROSS
-    -   Ellipse: CV_SHAPE_ELLIPSE
+    -   Rectangular box: Imgproc.SHAPE_RECT
+    -   Cross: Imgproc.SHAPE_CROSS
+    -   Ellipse: Imgproc.SHAPE_ELLIPSE
 
     Together with the shape we specify the size of our kernel and the *anchor point*. If the anchor point is not
     specified, it is assumed to be in the center.

doc/tutorials/imgproc/histograms/histogram_comparison/histogram_comparison.markdown

@@ -27,19 +27,19 @@ Theory
     (\f$d(H_{1}, H_{2})\f$) to express how well both histograms match.
 -   OpenCV implements the function @ref cv::compareHist to perform a comparison. It also offers 4
     different metrics to compute the matching:
-    -#  **Correlation ( CV_COMP_CORREL )**
+    -#  **Correlation ( cv::HISTCMP_CORREL )**
         \f[d(H_1,H_2) =  \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) - \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) - \bar{H_2})^2}}\f]
         where
         \f[\bar{H_k} =  \frac{1}{N} \sum _J H_k(J)\f]
         and \f$N\f$ is the total number of histogram bins.
 
-    -#  **Chi-Square ( CV_COMP_CHISQR )**
+    -#  **Chi-Square ( cv::HISTCMP_CHISQR )**
         \f[d(H_1,H_2) =  \sum _I  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\f]
 
-    -#  **Intersection ( method=CV_COMP_INTERSECT )**
+    -#  **Intersection ( method=cv::HISTCMP_INTERSECT )**
         \f[d(H_1,H_2) =  \sum _I  \min (H_1(I), H_2(I))\f]
 
-    -#  **Bhattacharyya distance ( CV_COMP_BHATTACHARYYA )**
+    -#  **Bhattacharyya distance ( cv::HISTCMP_BHATTACHARYYA )**
         \f[d(H_1,H_2) =  \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}}\f]
 
 Code

modules/calib3d/src/calibinit.cpp

@@ -101,8 +101,6 @@ namespace cv {
 
 #define MAX_CONTOUR_APPROX  7
 
-#define USE_CV_FINDCONTOURS  // switch between cv::findContours() and legacy C API
-#ifdef USE_CV_FINDCONTOURS
 struct QuadCountour {
     Point pt[4];
     int parent_contour;
@@ -113,18 +111,6 @@ struct QuadCountour {
         pt[0] = pt_[0]; pt[1] = pt_[1]; pt[2] = pt_[2]; pt[3] = pt_[3];
     }
 };
-#else
-
-} // namespace
-#include "opencv2/imgproc/imgproc_c.h"
-namespace cv {
-
-struct CvContourEx
-{
-    CV_CONTOUR_FIELDS()
-    int counter;
-};
-#endif
 
 
 /** This structure stores information about the chessboard corner.*/
@@ -552,13 +538,7 @@ bool findChessboardCorners(InputArray image_, Size pattern_size,
         rectangle( thresh_img_new, Point(0,0), Point(thresh_img_new.cols-1, thresh_img_new.rows-1), Scalar(255,255,255), 3, LINE_8);
 
         detector.reset();
-
-#ifdef USE_CV_FINDCONTOURS
-        Mat binarized_img = thresh_img_new;
-#else
-        Mat binarized_img = thresh_img_new.clone(); // make clone because cvFindContours modifies the source image
-#endif
-        detector.generateQuads(binarized_img, flags);
+        detector.generateQuads(thresh_img_new, flags);
         DPRINTF("Quad count: %d/%d", detector.all_quads_count, (pattern_size.width/2+1)*(pattern_size.height/2+1));
         SHOW_QUADS("New quads", thresh_img_new, &detector.all_quads[0], detector.all_quads_count);
         if (detector.processQuads(out_corners, prev_sqr_size))
@@ -623,13 +603,7 @@ bool findChessboardCorners(InputArray image_, Size pattern_size,
                 rectangle( thresh_img, Point(0,0), Point(thresh_img.cols-1, thresh_img.rows-1), Scalar(255,255,255), 3, LINE_8);
 
                 detector.reset();
-
-#ifdef USE_CV_FINDCONTOURS
-                Mat binarized_img = thresh_img;
-#else
-                Mat binarized_img = (useAdaptive) ? thresh_img : thresh_img.clone(); // make clone because cvFindContours modifies the source image
-#endif
-                detector.generateQuads(binarized_img, flags);
+                detector.generateQuads(thresh_img, flags);
                 DPRINTF("Quad count: %d/%d", detector.all_quads_count, (pattern_size.width/2+1)*(pattern_size.height/2+1));
                 SHOW_QUADS("Old quads", thresh_img, &detector.all_quads[0], detector.all_quads_count);
                 if (detector.processQuads(out_corners, prev_sqr_size))
@@ -1376,7 +1350,6 @@ int ChessBoardDetector::checkQuadGroup(std::vector<ChessBoardQuad*>& quad_group,
 
         for (int j = 0; j < 4; ++j)
         {
-            //cvLine( debug_img, cvPointFrom32f(q->corners[j]->pt), cvPointFrom32f(q->corners[(j+1)&3]->pt), color, 1, CV_AA, 0 );
             if (q->neighbors[j])
             {
                 int next_j = (j + 1) & 3;
@@ -1465,7 +1438,6 @@ int ChessBoardDetector::checkQuadGroup(std::vector<ChessBoardQuad*>& quad_group,
         goto finalize;
 
     cur->row = 0;
-    //cvCircle( debug_img, cvPointFrom32f(cur->pt), 3, cvScalar(0,255,0), -1, 8, 0 );
 
     first = below; // remember the first corner in the next row
 
@@ -1474,7 +1446,6 @@ int ChessBoardDetector::checkQuadGroup(std::vector<ChessBoardQuad*>& quad_group,
     {
         right->row = 0;
         out_corners.push_back(right);
-        //cvCircle( debug_img, cvPointFrom32f(right->pt), 3, cvScalar(0,255-j*10,0), -1, 8, 0 );
         if( right->count == 2 )
             break;
         if( right->count != 3 || (int)out_corners.size() >= std::max(pattern_size.width,pattern_size.height) )
@@ -1519,7 +1490,6 @@ int ChessBoardDetector::checkQuadGroup(std::vector<ChessBoardQuad*>& quad_group,
         {
             cur->row = i;
             out_corners.push_back(cur);
-            //cvCircle( debug_img, cvPointFrom32f(cur->pt), 3, cvScalar(0,0,255-j*10), -1, 8, 0 );
             if (cur->count == 2 + (i < height-1) && j > 0)
                 break;
 
@@ -1764,7 +1734,6 @@ void ChessBoardDetector::generateQuads(const cv::Mat& image_, int flags)
     int min_size = 25; //cvRound( image->cols * image->rows * .03 * 0.01 * 0.92 );
 
     bool filterQuads = (flags & CALIB_CB_FILTER_QUADS) != 0;
-#ifdef USE_CV_FINDCONTOURS // use cv::findContours
 
     std::vector<std::vector<Point> > contours;
     std::vector<Vec4i> hierarchy;
@@ -1879,122 +1848,6 @@ void ChessBoardDetector::generateQuads(const cv::Mat& image_, int flags)
         }
     }
 
-#else // use legacy API: cvStartFindContours / cvFindNextContour / cvEndFindContours
-
-    CvMat image_old = cvMat(image_), *image = &image_old;
-
-    CvContourEx* board = 0;
-
-    // create temporary storage for contours and the sequence of pointers to found quadrangles
-    cv::Ptr<CvMemStorage> temp_storage(cvCreateMemStorage(0));
-    CvSeq *root = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvSeq*), temp_storage);
-
-    // initialize contour retrieving routine
-    CvContourScanner scanner = cvStartFindContours(image, temp_storage, sizeof(CvContourEx),
-                                   CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
-
-    // get all the contours one by one
-    CvSeq* src_contour = NULL;
-    while ((src_contour = cvFindNextContour(scanner)) != NULL)
-    {
-        CvSeq *dst_contour = 0;
-        CvRect rect = ((CvContour*)src_contour)->rect;
-
-        // reject contours with too small perimeter
-        if( CV_IS_SEQ_HOLE(src_contour) && rect.width*rect.height >= min_size )
-        {
-            const int min_approx_level = 1, max_approx_level = MAX_CONTOUR_APPROX;
-            for (int approx_level = min_approx_level; approx_level <= max_approx_level; approx_level++ )
-            {
-                dst_contour = cvApproxPoly( src_contour, sizeof(CvContour), temp_storage,
-                                            CV_POLY_APPROX_DP, (float)approx_level );
-                if( dst_contour->total == 4 )
-                    break;
-
-                // we call this again on its own output, because sometimes
-                // cvApproxPoly() does not simplify as much as it should.
-                dst_contour = cvApproxPoly( dst_contour, sizeof(CvContour), temp_storage,
-                                            CV_POLY_APPROX_DP, (float)approx_level );
-
-                if( dst_contour->total == 4 )
-                    break;
-            }
-
-            // reject non-quadrangles
-            if( dst_contour->total == 4 && cvCheckContourConvexity(dst_contour) )
-            {
-                cv::Point2i pt[4];
-                double p = cvContourPerimeter(dst_contour);
-                double area = fabs(cvContourArea(dst_contour, CV_WHOLE_SEQ));
-
-                for (int i = 0; i < 4; ++i)
-                    pt[i] = *(CvPoint*)cvGetSeqElem(dst_contour, i);
-                CV_LOG_VERBOSE(NULL, 9, "... contours(" << root->total << " added):" << pt[0] << " " << pt[1] << " " << pt[2] << " " << pt[3]);
-
-                double d1 = sqrt(normL2Sqr<double>(pt[0] - pt[2]));
-                double d2 = sqrt(normL2Sqr<double>(pt[1] - pt[3]));
-
-                // philipg.  Only accept those quadrangles which are more square
-                // than rectangular and which are big enough
-                double d3 = sqrt(normL2Sqr<double>(pt[0] - pt[1]));
-                double d4 = sqrt(normL2Sqr<double>(pt[1] - pt[2]));
-                if (!filterQuads ||
-                    (d3*4 > d4 && d4*4 > d3 && d3*d4 < area*1.5 && area > min_size &&
-                    d1 >= 0.15 * p && d2 >= 0.15 * p))
-                {
-                    CvContourEx* parent = (CvContourEx*)(src_contour->v_prev);
-                    parent->counter++;
-                    if( !board || board->counter < parent->counter )
-                        board = parent;
-                    dst_contour->v_prev = (CvSeq*)parent;
-                    //for( i = 0; i < 4; i++ ) cvLine( debug_img, pt[i], pt[(i+1)&3], cvScalar(200,255,255), 1, CV_AA, 0 );
-                    cvSeqPush( root, &dst_contour );
-                }
-            }
-        }
-    }
-
-    // finish contour retrieving
-    cvEndFindContours( &scanner );
-
-    // allocate quad & corner buffers
-    int total = root->total;
-    size_t max_quad_buf_size = std::max((size_t)2, (size_t)total * 3);
-    all_quads.allocate(max_quad_buf_size);
-    all_corners.allocate(max_quad_buf_size * 4);
-
-    // Create array of quads structures
-    for (int idx = 0; idx < total; ++idx)
-    {
-        /* CvSeq* */src_contour = *(CvSeq**)cvGetSeqElem(root, idx);
-        if (filterQuads && src_contour->v_prev != (CvSeq*)board)
-            continue;
-
-        int quad_idx = quad_count++;
-        ChessBoardQuad& q = all_quads[quad_idx];
-
-        // reset group ID
-        q = ChessBoardQuad();
-        CV_Assert(src_contour->total == 4);
-        for (int i = 0; i < 4; i++)
-        {
-            Point* onePoint = (Point*)cvGetSeqElem(src_contour, i);
-            CV_Assert(onePoint != NULL);
-            Point2f pt(*onePoint);
-            ChessBoardCorner& corner = all_corners[quad_idx*4 + i];
-
-            corner = ChessBoardCorner(pt);
-            q.corners[i] = &corner;
-        }
-        q.edge_len = FLT_MAX;
-        for (int i = 0; i < 4; ++i)
-        {
-            float d = normL2Sqr<float>(q.corners[i]->pt - q.corners[(i+1)&3]->pt);
-            q.edge_len = std::min(q.edge_len, d);
-        }
-    }
-#endif
-
     all_quads_count = quad_count;
 
     CV_LOG_VERBOSE(NULL, 3, "Total quad contours: " << total);

modules/calib3d/test/test_undistort.cpp

@@ -998,7 +998,7 @@ TEST(DISABLED_Calib3d_InitInverseRectificationMap, accuracy) { CV_InitInverseRec
 ////////////////////////////// undistort /////////////////////////////////
 
 static void test_remap( const Mat& src, Mat& dst, const Mat& mapx, const Mat& mapy,
-                        Mat* mask=0, int interpolation=CV_INTER_LINEAR )
+                        Mat* mask=0, int interpolation=cv::INTER_LINEAR )
 {
     int x, y, k;
     int drows = dst.rows, dcols = dst.cols;
@@ -1009,7 +1009,7 @@ static void test_remap( const Mat& src, Mat& dst, const Mat& mapx, const Mat& ma
     int step = (int)(src.step / CV_ELEM_SIZE(depth));
     int delta;
 
-    if( interpolation != CV_INTER_CUBIC )
+    if( interpolation != cv::INTER_CUBIC )
     {
         delta = 0;
         scols -= 1; srows -= 1;
@@ -1318,7 +1318,7 @@ void CV_UndistortTest::get_test_array_types_and_sizes( int test_case_idx, vector
     sizes[INPUT][2] = cvtest::randInt(rng)%2 ? cvSize(4,1) : cvSize(1,4);
     types[INPUT][3] =  types[INPUT][1];
     sizes[INPUT][3] = sizes[INPUT][1];
-    interpolation = CV_INTER_LINEAR;
+    interpolation = cv::INTER_LINEAR;
 }
 
 

modules/core/include/opencv2/core/cuda.hpp

@@ -609,8 +609,8 @@ Below is an example that utilizes BufferPool with StackAllocator:
         GpuMat d_src2 = pool2.getBuffer(1024, 1024, CV_8UC1);   // 1MB
         GpuMat d_dst2 = pool2.getBuffer(1024, 1024, CV_8UC3);   // 3MB
 
-        cvtColor(d_src1, d_dst1, CV_GRAY2BGR, 0, stream1);
-        cvtColor(d_src2, d_dst2, CV_GRAY2BGR, 0, stream2);
+        cvtColor(d_src1, d_dst1, cv::COLOR_GRAY2BGR, 0, stream1);
+        cvtColor(d_src2, d_dst2, cv::COLOR_GRAY2BGR, 0, stream2);
     }
 @endcode
 
@@ -675,8 +675,8 @@ and the corresponding memory is automatically returned to the pool for later usa
             d_src1.setTo(Scalar(i), stream1);
             d_src2.setTo(Scalar(i), stream2);
 
-            cvtColor(d_src1, d_dst1, CV_GRAY2BGR, 0, stream1);
-            cvtColor(d_src2, d_dst2, CV_GRAY2BGR, 0, stream2);
+            cvtColor(d_src1, d_dst1, cv::COLOR_GRAY2BGR, 0, stream1);
+            cvtColor(d_src2, d_dst2, cv::COLOR_GRAY2BGR, 0, stream2);
                                                                     // The order of destruction of the local variables is:
                                                                     //   d_dst2 => d_src2 => d_dst1 => d_src1
                                                                     // LIFO rule is satisfied, this code runs without error

modules/gapi/include/opencv2/gapi/core.hpp

@@ -1418,7 +1418,7 @@ types.
  */
 GAPI_EXPORTS_W GMat threshold(const GMat& src, const GScalar& thresh, const GScalar& maxval, int type);
 /** @overload
-This function applicable for all threshold types except CV_THRESH_OTSU and CV_THRESH_TRIANGLE
+This function applicable for all threshold types except cv::THRESH_OTSU and cv::THRESH_TRIANGLE
 @note Function textual ID is "org.opencv.core.matrixop.thresholdOT"
 */
 GAPI_EXPORTS_W std::tuple<GMat, GScalar> threshold(const GMat& src, const GScalar& maxval, int type);

modules/imgproc/doc/pics/polar_remap_doc.svg

@@ -357,7 +357,7 @@ public void testCompareHist() {
         H1.put(0, 0, 1, 2, 3);
         H2.put(0, 0, 4, 5, 6);
 
-        double distance = Imgproc.compareHist(H1, H2, Imgproc.CV_COMP_CORREL);
+        double distance = Imgproc.compareHist(H1, H2, Imgproc.HISTCMP_CORREL);
 
         assertEquals(1., distance, EPS);
     }
@@ -636,7 +636,7 @@ public void testDistanceTransformWithLabels() {
         Mat dstLables = getMat(CvType.CV_32SC1, 0);
         Mat labels = new Mat();
 
-        Imgproc.distanceTransformWithLabels(gray128, dst, labels, Imgproc.CV_DIST_L2, 3);
+        Imgproc.distanceTransformWithLabels(gray128, dst, labels, Imgproc.DIST_L2, 3);
 
         assertMatEqual(dstLables, labels);
         assertMatEqual(getMat(CvType.CV_32FC1, 8192), dst, EPS);
@@ -813,7 +813,7 @@ public void testFitLine() {
         Mat linePoints = new Mat(4, 1, CvType.CV_32FC1);
         linePoints.put(0, 0, 0.53198653, 0.84675282, 2.5, 3.75);
 
-        Imgproc.fitLine(points, dst, Imgproc.CV_DIST_L12, 0, 0.01, 0.01);
+        Imgproc.fitLine(points, dst, Imgproc.DIST_L12, 0, 0.01, 0.01);
 
         assertMatEqual(linePoints, dst, EPS);
     }
@@ -1040,7 +1040,7 @@ public void testHoughCirclesMatMatIntDoubleDouble() {
         Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
         Mat circles = new Mat();
 
-        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
+        Imgproc.HoughCircles(img, circles, Imgproc.HOUGH_GRADIENT, 2, img.rows() / 4);
 
         assertEquals(0, circles.cols());
     }
@@ -1054,7 +1054,7 @@ public void testHoughCirclesMatMatIntDoubleDouble1() {
         int radius = Math.min(img.cols() / 4, img.rows() / 4);
         Imgproc.circle(img, center, radius, colorBlack, 3);
 
-        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
+        Imgproc.HoughCircles(img, circles, Imgproc.HOUGH_GRADIENT, 2, img.rows() / 4);
 
         assertEquals(1, circles.cols());
     }
@@ -1308,7 +1308,7 @@ public void testMatchShapes() {
         contour1.put(0, 0, 1, 1, 5, 1, 4, 3, 6, 2);
         contour2.put(0, 0, 1, 1, 6, 1, 4, 1, 2, 5);
 
-        double distance = Imgproc.matchShapes(contour1, contour2, Imgproc.CV_CONTOURS_MATCH_I1, 1);
+        double distance = Imgproc.matchShapes(contour1, contour2, Imgproc.CONTOURS_MATCH_I1, 1);
 
         assertEquals(2.81109697365334, distance, EPS);
     }