Test aruco detection with different number of threads

Test ensures that different aruco detection methods do not
produce different results based on number of threads.

Test was created after observing infinite loop caused
by small image and large number of threads when using
apriltag corner refinement.

Author: buq2

modules/aruco/test/test_arucodetection.cpp

@@ -717,4 +717,71 @@ TEST(CV_ArucoDetectMarkers, regression_2492)
     }
 }
 
+TEST(CV_ArucoDetectMarkers, number_of_threads_does_not_change_results)
+{
+    auto params = cv::aruco::DetectorParameters::create();
+    // We are not testing against different dictionaries
+    // As we are interested mostly in small images, smaller
+    // markers is better -> 4x4
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
+
+    // Height of the test image can be chosen quite freely
+    // We aim to test against small images as in those the
+    // number of threads has most effect
+    const auto height_img = 20;
+    // Just to get nice white boarder
+    const int shift = height_img > 10 ? 5 : 1;
+    const auto height_marker = height_img-2*shift;
+
+    // Create a test image
+    cv::Mat img_marker;
+    cv::aruco::drawMarker(dictionary, 23, height_marker, img_marker, 1);
+
+    // Copy to bigger image to get a white border
+    cv::Mat img(height_img, height_img, CV_8UC1);
+    img.setTo(255);
+    img_marker.copyTo(img(cv::Rect(shift, shift, height_marker, height_marker)));
+
+    // Remember original number of threads
+    const auto original_num_th = cv::getNumThreads();
+    for (const auto refinement_method : {cv::aruco::CORNER_REFINE_NONE, cv::aruco::CORNER_REFINE_SUBPIX,
+        cv::aruco::CORNER_REFINE_CONTOUR, cv::aruco::CORNER_REFINE_APRILTAG})
+    {
+        params->cornerRefinementMethod = refinement_method;
+
+        std::vector<std::vector<cv::Point2f>> original_corners;
+        std::vector<int> original_ids;
+        for (const auto num_threads : {1, 2, 8, 16, 32, height_img-1, height_img, height_img+1}) {
+            cv::setNumThreads(num_threads);
+
+            std::vector<std::vector<cv::Point2f>> corners;
+            std::vector<int> ids;
+            cv::aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+            // If we don't find any markers, the test is broken
+            ASSERT_GE(ids.size(), 1);
+
+            if (original_corners.empty()) {
+                original_corners = std::move(corners);
+                original_ids = std::move(ids);
+            } else {
+                // Make sure we got the same result as the first time
+                ASSERT_EQ(corners.size(), original_corners.size());
+                ASSERT_EQ(ids.size(), original_ids.size());
+                ASSERT_EQ(ids.size(), corners.size());
+                for (size_t i = 0; i < corners.size(); ++i) {
+                    EXPECT_EQ(ids[i], original_ids[i]);
+                    for (size_t j = 0; j < corners[i].size(); ++j) {
+                        EXPECT_NEAR(corners[i][j].x, original_corners[i][j].x, 0.1f);
+                        EXPECT_NEAR(corners[i][j].y, original_corners[i][j].y, 0.1f);
+                    }
+                }
+            }
+        }
+    }
+
+    // Reset number of threads
+    cv::setNumThreads(original_num_th);
+}
+
 }} // namespace