Merge pull request #26187 from inayd:26130-fixFillPolyBoundaries

asmorkalov · web-flow · commit 28efc2153019 · 2024-10-07T17:13:03.000+03:00
Fix fillPoly drawing over boundaries
diff --git a/modules/imgproc/src/drawing.cpp b/modules/imgproc/src/drawing.cpp
@@ -64,7 +64,7 @@ CollectPolyEdges( Mat& img, const Point2l* v, int npts,
                   int shift, Point offset=Point() );
 
 static void
-FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, int line_type);
+FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color );
 
 static void
 PolyLine( Mat& img, const Point2l* v, int npts, bool closed,
@@ -1051,7 +1051,7 @@ EllipseEx( Mat& img, Point2l center, Size2l axes,
         v.push_back(center);
         std::vector<PolyEdge> edges;
         CollectPolyEdges( img,  &v[0], (int)v.size(), edges, color, line_type, XY_SHIFT );
-        FillEdgeCollection( img, edges, color, line_type );
+        FillEdgeCollection( img, edges, color );
     }
 }
 
@@ -1299,15 +1299,11 @@ CollectPolyEdges( Mat& img, const Point2l* v, int count, std::vector<PolyEdge>&
                 if (t0.y != t1.y)
                 {
                     pt0c.y = t0.y; pt1c.y = t1.y;
-                    pt0c.x = (int64)(t0.x) << XY_SHIFT;
-                    pt1c.x = (int64)(t1.x) << XY_SHIFT;
                 }
             }
-            else
-            {
-                pt0c.x += XY_ONE >> 1;
-                pt1c.x += XY_ONE >> 1;
-            }
+
+            pt0c.x = (int64)(t0.x) << XY_SHIFT;
+            pt1c.x = (int64)(t1.x) << XY_SHIFT;
         }
         else
         {
@@ -1349,7 +1345,7 @@ struct CmpEdges
 /**************** helper macros and functions for sequence/contour processing ***********/
 
 static void
-FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, int line_type)
+FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color )
 {
     PolyEdge tmp;
     int i, y, total = (int)edges.size();
@@ -1358,12 +1354,7 @@ FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, i
     int y_max = INT_MIN, y_min = INT_MAX;
     int64 x_max = 0xFFFFFFFFFFFFFFFF, x_min = 0x7FFFFFFFFFFFFFFF;
     int pix_size = (int)img.elemSize();
-    int delta;
-
-    if (line_type < cv::LINE_AA)
-        delta = 0;
-    else
-        delta = XY_ONE - 1;
+    int delta = XY_ONE - 1;
 
     if( total < 2 )
         return;
@@ -2051,7 +2042,7 @@ void fillPoly( InputOutputArray _img, const Point** pts, const int* npts, int nc
         }
     }
 
-    FillEdgeCollection(img, edges, buf, line_type);
+    FillEdgeCollection(img, edges, buf);
 }
 
 void polylines( InputOutputArray _img, const Point* const* pts, const int* npts, int ncontours, bool isClosed,
@@ -2690,7 +2681,7 @@ cvDrawContours( void* _img, CvSeq* contour,
     }
 
     if( thickness < 0 )
-        cv::FillEdgeCollection( img, edges, ext_buf, line_type);
+        cv::FillEdgeCollection( img, edges, ext_buf );
 
     if( h_next && contour0 )
         contour0->h_next = h_next;
diff --git a/modules/imgproc/test/test_drawing.cpp b/modules/imgproc/test/test_drawing.cpp
@@ -680,6 +680,75 @@ TEST(Drawing, fillpoly_circle)
     EXPECT_LT(diff_fp3, 1.);
 }
 
+TEST(Drawing, fillpoly_contours)
+{
+    const int imgSize = 50;
+    const int type = CV_8UC1;
+    const int shift = 0;
+    const Scalar cl = Scalar::all(255);
+    const cv::LineTypes lineType = LINE_8;
+
+    // check that contours of fillPoly and polylines match
+    {
+        cv::Mat img(imgSize, imgSize, type);
+        img = 0;
+        std::vector<std::vector<cv::Point>> polygonPoints{
+            { {44, 27}, {7, 37}, {7, 19}, {38, 19} }
+        };
+        cv::fillPoly(img, polygonPoints, cl, lineType, shift);
+        cv::polylines(img, polygonPoints, true, 0, 1, lineType, shift);
+
+        {
+            cv::Mat labelImage(img.size(), CV_32S);
+            int labels = cv::connectedComponents(img, labelImage, 4);
+            EXPECT_EQ(2, labels) << "filling went over the border";
+        }
+    }
+
+    // check that line generated with fillPoly and polylines match
+    {
+        cv::Mat img1(imgSize, imgSize, type), img2(imgSize, imgSize, type);
+        img1 = 0;
+        img2 = 0;
+        std::vector<std::vector<cv::Point>> polygonPoints{
+            { {44, 27}, {38, 19} }
+        };
+        cv::fillPoly(img1, polygonPoints, cl, lineType, shift);
+        cv::polylines(img2, polygonPoints, true, cl, 1, lineType, shift);
+        EXPECT_MAT_N_DIFF(img1, img2, 0);
+    }
+}
+
+TEST(Drawing, fillpoly_match_lines)
+{
+    const int imgSize = 49;
+    const int type = CV_8UC1;
+    const int shift = 0;
+    const Scalar cl = Scalar::all(255);
+    const cv::LineTypes lineType = LINE_8;
+    cv::Mat img1(imgSize, imgSize, type), img2(imgSize, imgSize, type);
+    for (int x1 = 0; x1 < imgSize; x1 += imgSize / 2)
+    {
+        for (int y1 = 0; y1 < imgSize; y1 += imgSize / 2)
+        {
+            for (int x2 = 0; x2 < imgSize; x2++)
+            {
+                for (int y2 = 0; y2 < imgSize; y2++)
+                {
+                    img1 = 0;
+                    img2 = 0;
+                    std::vector<std::vector<cv::Point>> polygonPoints{
+                        { {x1, y1}, {x2, y2} }
+                    };
+                    cv::fillPoly(img1, polygonPoints, cl, lineType, shift);
+                    cv::polylines(img2, polygonPoints, true, cl, 1, lineType, shift);
+                    EXPECT_MAT_N_DIFF(img1, img2, 0);
+                }
+            }
+        }
+    }
+}
+
 TEST(Drawing, fillpoly_fully)
 {
     unsigned imageWidth = 256;

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ CollectPolyEdges( Mat& img, const Point2l* v, int npts,`
`64`	`64`	`int shift, Point offset=Point() );`
`65`	`65`
`66`	`66`	`static void`
`67`		`-FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, int line_type);`
	`67`	`+FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color );`
`68`	`68`
`69`	`69`	`static void`
`70`	`70`	`PolyLine( Mat& img, const Point2l* v, int npts, bool closed,`
`@@ -1051,7 +1051,7 @@ EllipseEx( Mat& img, Point2l center, Size2l axes,`
`1051`	`1051`	`v.push_back(center);`
`1052`	`1052`	`std::vector<PolyEdge> edges;`
`1053`	`1053`	`CollectPolyEdges( img, &v[0], (int)v.size(), edges, color, line_type, XY_SHIFT );`
`1054`		`- FillEdgeCollection( img, edges, color, line_type );`
	`1054`	`+ FillEdgeCollection( img, edges, color );`
`1055`	`1055`	`}`
`1056`	`1056`	`}`
`1057`	`1057`
`@@ -1299,15 +1299,11 @@ CollectPolyEdges( Mat& img, const Point2l* v, int count, std::vector<PolyEdge>&`
`1299`	`1299`	`if (t0.y != t1.y)`
`1300`	`1300`	`{`
`1301`	`1301`	`pt0c.y = t0.y; pt1c.y = t1.y;`
`1302`		`- pt0c.x = (int64)(t0.x) << XY_SHIFT;`
`1303`		`- pt1c.x = (int64)(t1.x) << XY_SHIFT;`
`1304`	`1302`	`}`
`1305`	`1303`	`}`
`1306`		`- else`
`1307`		`- {`
`1308`		`- pt0c.x += XY_ONE >> 1;`
`1309`		`- pt1c.x += XY_ONE >> 1;`
`1310`		`- }`
	`1304`	`+`
	`1305`	`+ pt0c.x = (int64)(t0.x) << XY_SHIFT;`
	`1306`	`+ pt1c.x = (int64)(t1.x) << XY_SHIFT;`
`1311`	`1307`	`}`
`1312`	`1308`	`else`
`1313`	`1309`	`{`
`@@ -1349,7 +1345,7 @@ struct CmpEdges`
`1349`	`1345`	`/************** helper macros and functions for sequence/contour processing *********/`
`1350`	`1346`
`1351`	`1347`	`static void`
`1352`		`-FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, int line_type)`
	`1348`	`+FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color )`
`1353`	`1349`	`{`
`1354`	`1350`	`PolyEdge tmp;`
`1355`	`1351`	`int i, y, total = (int)edges.size();`
`@@ -1358,12 +1354,7 @@ FillEdgeCollection( Mat& img, std::vector<PolyEdge>& edges, const void* color, i`
`1358`	`1354`	`int y_max = INT_MIN, y_min = INT_MAX;`
`1359`	`1355`	`int64 x_max = 0xFFFFFFFFFFFFFFFF, x_min = 0x7FFFFFFFFFFFFFFF;`
`1360`	`1356`	`int pix_size = (int)img.elemSize();`
`1361`		`- int delta;`
`1362`		`-`
`1363`		`- if (line_type < cv::LINE_AA)`
`1364`		`- delta = 0;`
`1365`		`- else`
`1366`		`- delta = XY_ONE - 1;`
	`1357`	`+ int delta = XY_ONE - 1;`
`1367`	`1358`
`1368`	`1359`	`if( total < 2 )`
`1369`	`1360`	`return;`
`@@ -2051,7 +2042,7 @@ void fillPoly( InputOutputArray _img, const Point** pts, const int* npts, int nc`
`2051`	`2042`	`}`
`2052`	`2043`	`}`
`2053`	`2044`
`2054`		`- FillEdgeCollection(img, edges, buf, line_type);`
	`2045`	`+ FillEdgeCollection(img, edges, buf);`
`2055`	`2046`	`}`
`2056`	`2047`
`2057`	`2048`	`void polylines( InputOutputArray _img, const Point* const* pts, const int* npts, int ncontours, bool isClosed,`
`@@ -2690,7 +2681,7 @@ cvDrawContours( void* _img, CvSeq* contour,`
`2690`	`2681`	`}`
`2691`	`2682`
`2692`	`2683`	`if( thickness < 0 )`
`2693`		`- cv::FillEdgeCollection( img, edges, ext_buf, line_type);`
	`2684`	`+ cv::FillEdgeCollection( img, edges, ext_buf );`
`2694`	`2685`
`2695`	`2686`	`if( h_next && contour0 )`
`2696`	`2687`	`contour0->h_next = h_next;`