add check corners and ids

Author: AleksandrPanov

modules/aruco/test/test_arucodetection.cpp

@@ -564,9 +564,30 @@ TEST(CV_ArucoTutorial, can_find_singlemarkersoriginal)
     vector< int > ids;
     vector< vector< Point2f > > corners, rejected;
     Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    const size_t N = 6ull;
+    // corners of ArUco markers with indices goldCornersIds
+    const int goldCorners[N][8] = { {359,310, 404,310, 410,350, 362,350}, {427,255, 469,256, 477,289, 434,288},
+                                    {233,273, 190,273, 196,241, 237,241}, {298,185, 334,186, 335,212, 297,211},
+                                    {425,163, 430,186, 394,186, 390,162}, {195,155, 230,155, 227,178, 190,178} };
+    const int goldCornersIds[N] = { 40, 98, 62, 23, 124, 203};
+    map<int, const int*> mapGoldCorners;
+    for (size_t i = 0; i < N; i++)
+        mapGoldCorners[goldCornersIds[i]] = goldCorners[i];
 
     aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
-    EXPECT_EQ(6, (int)ids.size());
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[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]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), corners[i][j].y, 1.f);
+        }
+    }
 }
 
 TEST(CV_ArucoTutorial, can_find_gboriginal)
@@ -581,9 +602,45 @@ TEST(CV_ArucoTutorial, can_find_gboriginal)
     vector< int > ids;
     vector< vector< Point2f > > corners, rejected;
     Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    const size_t N = 35ull;
+    // corners of ArUco markers with indices 0, 1, ..., 34
+    const int goldCorners[N][8] = { {252,74, 286,81, 274,102, 238,95},    {295,82, 330,89, 319,111, 282,104},
+                                    {338,91, 375,99, 365,121, 327,113},   {383,100, 421,107, 412,130, 374,123},
+                                    {429,109, 468,116, 461,139, 421,132}, {235,100, 270,108, 257,130, 220,122},
+                                    {279,109, 316,117, 304,140, 266,133}, {324,119, 362,126, 352,150, 313,143},
+                                    {371,128, 410,136, 400,161, 360,152}, {418,139, 459,145, 451,170, 410,163},
+                                    {216,128, 253,136, 239,161, 200,152}, {262,138, 300,146, 287,172, 248,164},
+                                    {309,148, 349,156, 337,183, 296,174}, {358,158, 398,167, 388,194, 346,185},
+                                    {407,169, 449,176, 440,205, 397,196}, {196,158, 235,168, 218,195, 179,185},
+                                    {243,170, 283,178, 269,206, 228,197}, {293,180, 334,190, 321,218, 279,209},
+                                    {343,192, 385,200, 374,230, 330,220}, {395,203, 438,211, 429,241, 384,233},
+                                    {174,192, 215,201, 197,231, 156,221}, {223,204, 265,213, 249,244, 207,234},
+                                    {275,215, 317,225, 303,257, 259,246}, {327,227, 371,238, 359,270, 313,259},
+                                    {381,240, 426,249, 416,282, 369,273}, {151,228, 193,238, 173,271, 130,260},
+                                    {202,241, 245,251, 228,285, 183,274}, {255,254, 300,264, 284,299, 238,288},
+                                    {310,267, 355,278, 342,314, 295,302}, {366,281, 413,290, 402,327, 353,317},
+                                    {125,267, 168,278, 147,314, 102,303}, {178,281, 223,293, 204,330, 157,317},
+                                    {233,296, 280,307, 263,346, 214,333}, {291,310, 338,322, 323,363, 274,349},
+                                    {349,325, 399,336, 386,378, 335,366} };
+    map<int, const int*> mapGoldCorners;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        mapGoldCorners[i] = goldCorners[i];
 
     aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
-    EXPECT_EQ(35, (int)ids.size());
+
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[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]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j*2+1]), corners[i][j].y, 1.f);
+        }
+    }
 }
 
 }} // namespace

modules/aruco/test/test_charucodetection.cpp

@@ -36,7 +36,6 @@ or tort (including negligence or otherwise) arising in any way out of
 the use of this software, even if advised of the possibility of such damage.
 */
 
-
 #include "test_precomp.hpp"
 #include "../samples/samples_utility.hpp"
 
@@ -687,9 +686,35 @@ TEST(CV_ArucoTutorial, can_find_choriginal)
     vector< int > ids;
     vector< vector< Point2f > > corners, rejected;
     Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    const size_t N = 17;
+    // corners of aruco markers with indices goldCornersIds
+    const int goldCorners[N][8] = { {268, 77,290, 80,286, 97,263, 94}, {360, 90,382, 93,379, 111,357, 108},
+                                    {211, 106,233, 109,228, 127,205, 123}, {306, 120,328, 124,325, 142,302, 138},
+                                    {402, 135,425, 139,423, 157,400, 154}, {247, 152,271, 155,267, 174,242, 171},
+                                    {347, 167,371, 171,369, 191,344, 187}, {185, 185,209, 189,203, 210,178, 206},
+                                    {288, 201,313, 206,309, 227,284, 223}, {393, 218,418, 222,416, 245,391, 241},
+                                    {223, 240,250, 244,244, 268,217, 263}, {333, 258,359, 262,356, 286,329, 282},
+                                    {152, 281,179, 285,171, 312,143, 307}, {267, 300,294, 305,289, 331,261, 327},
+                                    {383, 319,410, 324,408, 351,380, 347}, {194, 347,223, 352,216, 382,186, 377},
+                                    {315, 368,345, 373,341, 403,310, 398} };
+    map<int, const int*> mapGoldCorners;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        mapGoldCorners[i] = goldCorners[i];
 
     aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
-    EXPECT_EQ(17, (int)ids.size());
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[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]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), corners[i][j].y, 1.f);
+        }
+    }
 }
 
 TEST(CV_ArucoTutorial, can_find_chocclusion)
@@ -701,9 +726,11 @@ TEST(CV_ArucoTutorial, can_find_chocclusion)
     vector< int > ids;
     vector< vector< Point2f > > corners, rejected;
     Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    const size_t N = 13;
 
     aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
-    EXPECT_EQ(13, (int)ids.size());
+
+    EXPECT_EQ(N, ids.size());
 }
 
 TEST(CV_ArucoTutorial, can_find_diamondmarkers)
@@ -722,9 +749,23 @@ TEST(CV_ArucoTutorial, can_find_diamondmarkers)
     Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
     readDetectorParameters(detectorPath, detectorParams);
     detectorParams->cornerRefinementMethod = 3;
+    const size_t N = 12;
+    // corner indices of ArUco markers
+    const int goldCornersIds[N] = { 4, 12, 11, 3, 12, 10, 12, 10, 10, 11, 2, 11 };
+    map<int, int> counterGoldCornersIds;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        counterGoldCornersIds[goldCornersIds[i]]++;
 
     aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
-    EXPECT_EQ(12, (int)ids.size());
+    map<int, int> counterRes;
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        counterRes[arucoId]++;
+    }
+
+    ASSERT_EQ(N, ids.size());
+    EXPECT_EQ(counterGoldCornersIds, counterRes); // check the number of ArUco markers
 }
 
 }} // namespace