Merge pull request opencv#3201 from AleksandrPanov:fix_filterTooCloseCandidates

* fix search for one contour in _filterTooCloseCandidates()

* add regression_3192 test

* add regression_2492 test

(cherry picked from commit ef5a7e8)

Author: Alexander Panov

modules/aruco/src/aruco.cpp

@@ -295,11 +295,11 @@ static void _filterTooCloseCandidates(const vector< vector< Point2f > > &candida
                                       double minMarkerDistanceRate, bool detectInvertedMarker) {
 
     CV_Assert(minMarkerDistanceRate >= 0);
-
     vector<int> candGroup;
     candGroup.resize(candidatesIn.size(), -1);
     vector< vector<unsigned int> > groupedCandidates;
     for(unsigned int i = 0; i < candidatesIn.size(); i++) {
+        bool isSingleContour = true;
         for(unsigned int j = i + 1; j < candidatesIn.size(); j++) {
 
             int minimumPerimeter = min((int)contoursIn[i].size(), (int)contoursIn[j].size() );
@@ -320,7 +320,7 @@ static void _filterTooCloseCandidates(const vector< vector< Point2f > > &candida
                 // if mean square distance is too low, remove the smaller one of the two markers
                 double minMarkerDistancePixels = double(minimumPerimeter) * minMarkerDistanceRate;
                 if(distSq < minMarkerDistancePixels * minMarkerDistancePixels) {
-
+                    isSingleContour = false;
                     // i and j are not related to a group
                     if(candGroup[i]<0 && candGroup[j]<0){
                         // mark candidates with their corresponding group number
@@ -351,6 +351,14 @@ static void _filterTooCloseCandidates(const vector< vector< Point2f > > &candida
                 }
             }
         }
+        if (isSingleContour && candGroup[i] < 0)
+        {
+            candGroup[i] = (int)groupedCandidates.size();
+            vector<unsigned int> grouped;
+            grouped.push_back(i);
+            grouped.push_back(i); // step "save possible candidates" require minimum 2 elements
+            groupedCandidates.push_back(grouped);
+        }
     }
 
     // save possible candidates

modules/aruco/test/test_arucodetection.cpp

@@ -655,4 +655,77 @@ TEST(CV_ArucoTutorial, can_find_gboriginal)
     }
 }
 
+TEST(CV_ArucoDetectMarkers, regression_3192)
+{
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_4X4_50);
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    vector< int > markerIds;
+    vector<vector<Point2f> > markerCorners;
+    string imgPath = cvtest::findDataFile("aruco/regression_3192.png");
+    Mat image = imread(imgPath);
+    const size_t N = 2ull;
+    const int goldCorners[N][8] = { {345,120, 520,120, 520,295, 345,295}, {101,114, 270,112, 276,287, 101,287} };
+    const int goldCornersIds[N] = { 6, 4 };
+    map<int, const int*> mapGoldCorners;
+    for (size_t i = 0; i < N; i++)
+        mapGoldCorners[goldCornersIds[i]] = goldCorners[i];
+
+    aruco::detectMarkers(image, dictionary, markerCorners, markerIds, detectorParams);
+
+    ASSERT_EQ(N, markerIds.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = markerIds[i];
+        ASSERT_EQ(4ull, markerCorners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2]), markerCorners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), markerCorners[i][j].y, 1.f);
+        }
+    }
+}
+
+TEST(CV_ArucoDetectMarkers, regression_2492)
+{
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_5X5_50);
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    detectorParams->minMarkerDistanceRate = 0.026;
+    vector< int > markerIds;
+    vector<vector<Point2f> > markerCorners;
+    string imgPath = cvtest::findDataFile("aruco/regression_2492.png");
+    Mat image = imread(imgPath);
+    const size_t N = 8ull;
+    const int goldCorners[N][8] = { {179,139, 179,95, 223,95, 223,139}, {99,139, 99,95, 143,95, 143,139},
+                                    {19,139, 19,95, 63,95, 63,139},     {256,140, 256,93, 303,93, 303,140},
+                                    {256,62, 259,21, 300,23, 297,64},   {99,21, 143,17, 147,60, 103,64},
+                                    {69,61, 28,61, 14,21, 58,17},       {174,62, 182,13, 230,19, 223,68} };
+    const int goldCornersIds[N] = {13, 13, 13, 13, 1, 15, 14, 4};
+    map<int, vector<const int*> > mapGoldCorners;
+    for (size_t i = 0; i < N; i++)
+        mapGoldCorners[goldCornersIds[i]].push_back(goldCorners[i]);
+
+    aruco::detectMarkers(image, dictionary, markerCorners, markerIds, detectorParams);
+
+    ASSERT_EQ(N, markerIds.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = markerIds[i];
+        ASSERT_EQ(4ull, markerCorners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        float totalDist = 8.f;
+        for (size_t k = 0ull; k < mapGoldCorners[arucoId].size(); k++)
+        {
+            float dist = 0.f;
+            for (int j = 0; j < 4; j++) // total distance up to 4 points
+            {
+                dist += abs(mapGoldCorners[arucoId][k][j * 2] - markerCorners[i][j].x);
+                dist += abs(mapGoldCorners[arucoId][k][j * 2 + 1] - markerCorners[i][j].y);
+            }
+            totalDist = min(totalDist, dist);
+        }
+        EXPECT_LT(totalDist, 8.f);
+    }
+}
+
 }} // namespace

modules/aruco/test/test_charucodetection.cpp

@@ -801,15 +801,16 @@ TEST(Charuco, issue_14014)
     ASSERT_EQ(corners.size(), 19ull);
     EXPECT_EQ(Size(4, 1), corners[0].size()); // check dimension of detected corners
 
-    ASSERT_EQ(rejectedPoints.size(), 21ull);
+    size_t numRejPoints = rejectedPoints.size();
+    ASSERT_EQ(rejectedPoints.size(), 26ull); // optional check to track regressions
     EXPECT_EQ(Size(4, 1), rejectedPoints[0].size()); // check dimension of detected corners
 
     aruco::refineDetectedMarkers(img, board, corners, ids, rejectedPoints);
 
     ASSERT_EQ(corners.size(), 20ull);
     EXPECT_EQ(Size(4, 1), corners[0].size()); // check dimension of rejected corners after successfully refine
 
-    ASSERT_EQ(rejectedPoints.size(), 20ull);
+    ASSERT_EQ(rejectedPoints.size() + 1, numRejPoints);
     EXPECT_EQ(Size(4, 1), rejectedPoints[0].size()); // check dimension of rejected corners after successfully refine
 }