Merge pull request #23264 from AleksandrPanov:add_detect_qr_with_aruco

Add detect qr with aruco #23264

Using Aruco to detect finder patterns to search QR codes.

TODO (in next PR):
- add single QR detect (update `detect()` and `detectAndDecode()`)
- need reduce full enumeration of finder patterns
- need add finder pattern info to `decode` step
- need to merge the pipeline of the old and new algorithm

[Current results:](https://docs.google.com/spreadsheets/d/1ufKyR-Zs-IGXwvqPgftssmTlceVjiQX364sbrjr2QU8/edit#gid=1192415584)
+20% total detect, +8% total decode in OpenCV [QR benchmark](https://github.com/opencv/opencv_benchmarks/tree/develop/python_benchmarks/qr_codes) 

![res1](https://user-images.githubusercontent.com/22337800/231228556-191d3eae-a318-44e1-af99-e7d420bf6248.png)


78.4% detect, 58.7% decode vs 58.5 detect, 50.5% decode in default

[main.py.txt](https://github.com/opencv/opencv/files/10762369/main.py.txt)

![res2](https://user-images.githubusercontent.com/22337800/231229123-ed7f1eda-159a-444b-a3ff-f107d8eb4a20.png)


add new info to [google docs](https://docs.google.com/spreadsheets/d/1ufKyR-Zs-IGXwvqPgftssmTlceVjiQX364sbrjr2QU8/edit?usp=sharing)


### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake

modules/objdetect/include/opencv2/objdetect.hpp

@@ -45,6 +45,7 @@
 #define OPENCV_OBJDETECT_HPP
 
 #include "opencv2/core.hpp"
+#include "opencv2/objdetect/aruco_detector.hpp"
 
 /**
 @defgroup objdetect Object Detection
@@ -763,28 +764,15 @@ public:
 
 };
 
-class CV_EXPORTS_W QRCodeDetector
-{
+class CV_EXPORTS_W_SIMPLE QRCodeDetectorBase {
 public:
-    CV_WRAP QRCodeDetector();
-    ~QRCodeDetector();
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    QRCodeDetectorBase();
 
-    /** @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.
-     @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern
-     of the scheme 1:1:3:1:1 according to QR code standard.
-    */
-    CV_WRAP void setEpsX(double epsX);
-    /** @brief sets the epsilon used during the vertical scan of QR code stop marker detection.
-     @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern
-     of the scheme 1:1:3:1:1 according to QR code standard.
-     */
-    CV_WRAP void setEpsY(double epsY);
-
-    /** @brief use markers to improve the position of the corners of the QR code
-     *
-     * alignmentMarkers using by default
-     */
-    CV_WRAP void setUseAlignmentMarkers(bool useAlignmentMarkers);
+    QRCodeDetectorBase(const QRCodeDetectorBase&) = default;
+    QRCodeDetectorBase(QRCodeDetectorBase&&) = default;
+    QRCodeDetectorBase& operator=(const QRCodeDetectorBase&) = default;
+    QRCodeDetectorBase& operator=(QRCodeDetectorBase&&) = default;
 
     /** @brief Detects QR code in image and returns the quadrangle containing the code.
      @param img grayscale or color (BGR) image containing (or not) QR code.
@@ -799,16 +787,7 @@ public:
      @param points Quadrangle vertices found by detect() method (or some other algorithm).
      @param straight_qrcode The optional output image containing rectified and binarized QR code
      */
-    CV_WRAP std::string decode(InputArray img, InputArray points, OutputArray straight_qrcode = noArray());
-
-    /** @brief Decodes QR code on a curved surface in image once it's found by the detect() method.
-
-     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
-     @param img grayscale or color (BGR) image containing QR code.
-     @param points Quadrangle vertices found by detect() method (or some other algorithm).
-     @param straight_qrcode The optional output image containing rectified and binarized QR code
-     */
-    CV_WRAP cv::String decodeCurved(InputArray img, InputArray points, OutputArray straight_qrcode = noArray());
+    CV_WRAP std::string decode(InputArray img, InputArray points, OutputArray straight_qrcode = noArray()) const;
 
     /** @brief Both detects and decodes QR code
 
@@ -817,16 +796,8 @@ public:
      @param straight_qrcode The optional output image containing rectified and binarized QR code
      */
     CV_WRAP std::string detectAndDecode(InputArray img, OutputArray points=noArray(),
-                                        OutputArray straight_qrcode = noArray());
-
-    /** @brief Both detects and decodes QR code on a curved surface
+                                        OutputArray straight_qrcode = noArray()) const;
 
-     @param img grayscale or color (BGR) image containing QR code.
-     @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.
-     @param straight_qrcode The optional output image containing rectified and binarized QR code
-     */
-    CV_WRAP std::string detectAndDecodeCurved(InputArray img, OutputArray points=noArray(),
-                                              OutputArray straight_qrcode = noArray());
 
     /** @brief Detects QR codes in image and returns the vector of the quadrangles containing the codes.
      @param img grayscale or color (BGR) image containing (or not) QR codes.
@@ -860,18 +831,109 @@ public:
             OutputArray points = noArray(),
             OutputArrayOfArrays straight_qrcode = noArray()
     ) const;
-
-protected:
     struct Impl;
+protected:
     Ptr<Impl> p;
 };
 
+class CV_EXPORTS_W_SIMPLE QRCodeDetector : public QRCodeDetectorBase
+{
+public:
+    CV_WRAP QRCodeDetector();
+
+    /** @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.
+     @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+    */
+    CV_WRAP QRCodeDetector& setEpsX(double epsX);
+    /** @brief sets the epsilon used during the vertical scan of QR code stop marker detection.
+     @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+     */
+    CV_WRAP QRCodeDetector& setEpsY(double epsY);
+
+    /** @brief use markers to improve the position of the corners of the QR code
+     *
+     * alignmentMarkers using by default
+     */
+    CV_WRAP QRCodeDetector& setUseAlignmentMarkers(bool useAlignmentMarkers);
+
+    /** @brief Decodes QR code on a curved surface in image once it's found by the detect() method.
+
+     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP cv::String decodeCurved(InputArray img, InputArray points, OutputArray straight_qrcode = noArray());
+
+    /** @brief Both detects and decodes QR code on a curved surface
+
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP std::string detectAndDecodeCurved(InputArray img, OutputArray points=noArray(),
+                                              OutputArray straight_qrcode = noArray());
+};
+
+class CV_EXPORTS_W_SIMPLE QRCodeDetectorAruco : public QRCodeDetectorBase {
+public:
+    CV_WRAP QRCodeDetectorAruco();
+
+    struct CV_EXPORTS_W_SIMPLE Params {
+        CV_WRAP Params();
+
+        /** @brief The minimum allowed pixel size of a QR module in the smallest image in the image pyramid, default 4.f */
+        CV_PROP_RW float minModuleSizeInPyramid;
+
+        /** @brief The maximum allowed relative rotation for finder patterns in the same QR code, default pi/12 */
+        CV_PROP_RW float maxRotation;
+
+        /** @brief The maximum allowed relative mismatch in module sizes for finder patterns in the same QR code, default 1.75f */
+        CV_PROP_RW float maxModuleSizeMismatch;
+
+        /** @brief The maximum allowed module relative mismatch for timing pattern module, default 2.f
+         *
+         * If relative mismatch of timing pattern module more this value, penalty points will be added.
+         * If a lot of penalty points are added, QR code will be rejected. */
+        CV_PROP_RW float maxTimingPatternMismatch;
+
+        /** @brief The maximum allowed percentage of penalty points out of total pins in timing pattern, default 0.4f */
+        CV_PROP_RW float maxPenalties;
+
+        /** @brief The maximum allowed relative color mismatch in the timing pattern, default 0.2f*/
+        CV_PROP_RW float maxColorsMismatch;
+
+        /** @brief The algorithm find QR codes with almost minimum timing pattern score and minimum size, default 0.9f
+         *
+         * The QR code with the minimum "timing pattern score" and minimum "size" is selected as the best QR code.
+         * If for the current QR code "timing pattern score" * scaleTimingPatternScore < "previous timing pattern score" and "size" < "previous size", then
+         * current QR code set as the best QR code. */
+        CV_PROP_RW float scaleTimingPatternScore;
+    };
+
+    /** @brief QR code detector constructor for Aruco-based algorithm. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP explicit QRCodeDetectorAruco(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Detector parameters getter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP const QRCodeDetectorAruco::Params& getDetectorParameters() const;
+
+    /** @brief Detector parameters setter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP QRCodeDetectorAruco& setDetectorParameters(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP aruco::DetectorParameters getArucoParameters();
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP void setArucoParameters(const aruco::DetectorParameters& params);
+};
+
 //! @}
 }
 
 #include "opencv2/objdetect/detection_based_tracker.hpp"
 #include "opencv2/objdetect/face.hpp"
-#include "opencv2/objdetect/aruco_detector.hpp"
 #include "opencv2/objdetect/charuco_detector.hpp"
 
 #endif

modules/objdetect/misc/objc/gen_dict.json

+{
+    "ManualFuncs" : {
+        "QRCodeDetectorAruco": {
+            "getDetectorParameters": { "declaration" : [""], "implementation" : [""] }
+        }
+    }
+}

modules/objdetect/perf/perf_qrcode_pipeline.cpp

@@ -3,6 +3,7 @@
 // of this distribution and at http://opencv.org/license.html.
 
 #include "perf_precomp.hpp"
+#include "../test/test_qr_utils.hpp"
 
 namespace opencv_test
 {
@@ -23,7 +24,9 @@ PERF_TEST_P_(Perf_Objdetect_QRCode, detect)
     std::vector< Point > corners;
     QRCodeDetector qrcode;
     TEST_CYCLE() ASSERT_TRUE(qrcode.detect(src, corners));
-    SANITY_CHECK(corners);
+    const int pixels_error = 3;
+    check_qr(root, name_current_image, "test_images", corners, {}, pixels_error);
+    SANITY_CHECK_NOTHING();
 }
 
 #ifdef HAVE_QUIRC
@@ -45,48 +48,52 @@ PERF_TEST_P_(Perf_Objdetect_QRCode, decode)
         decoded_info = qrcode.decode(src, corners, straight_barcode);
         ASSERT_FALSE(decoded_info.empty());
     }
-
-    std::vector<uint8_t> decoded_info_uint8_t(decoded_info.begin(), decoded_info.end());
-    SANITY_CHECK(decoded_info_uint8_t);
-    SANITY_CHECK(straight_barcode);
-
+    const int pixels_error = 3;
+    check_qr(root, name_current_image, "test_images", corners, {decoded_info}, pixels_error);
+    SANITY_CHECK_NOTHING();
 }
 #endif
 
-typedef ::perf::TestBaseWithParam< std::string > Perf_Objdetect_QRCode_Multi;
+typedef ::perf::TestBaseWithParam<std::tuple<std::string, std::string>> Perf_Objdetect_QRCode_Multi;
 
-static inline bool compareCorners(const Point2f& corner1, const Point2f& corner2) {
-    return corner1.x == corner2.x ? corner1.y < corner2.y : corner1.x < corner2.x;
-}
+static std::set<std::pair<std::string, std::string>> disabled_samples = {{"5_qrcodes.png", "aruco_based"}};
 
 PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, detectMulti)
 {
-    const std::string name_current_image = GetParam();
+    const std::string name_current_image = get<0>(GetParam());
+    const std::string method = get<1>(GetParam());
     const std::string root = "cv/qrcode/multiple/";
 
     std::string image_path = findDataFile(root + name_current_image);
     Mat src = imread(image_path);
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
-    std::vector<Point2f> corners;
-    QRCodeDetector qrcode;
+    std::vector<Point> corners;
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     TEST_CYCLE() ASSERT_TRUE(qrcode.detectMulti(src, corners));
-    sort(corners.begin(), corners.end(), compareCorners);
-    SANITY_CHECK(corners);
-}
-
-static inline bool compareQR(const pair<string, Mat>& v1, const pair<string, Mat>& v2) {
-    return v1.first < v2.first;
+    const int pixels_error = 7;
+    check_qr(root, name_current_image, "multiple_images", corners, {}, pixels_error, true);
+    SANITY_CHECK_NOTHING();
 }
 
 #ifdef HAVE_QUIRC
 PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, decodeMulti)
 {
-    const std::string name_current_image = GetParam();
+    const std::string name_current_image = get<0>(GetParam());
+    std::string method = get<1>(GetParam());
     const std::string root = "cv/qrcode/multiple/";
     std::string image_path = findDataFile(root + name_current_image);
     Mat src = imread(image_path);
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
-    QRCodeDetector qrcode;
+    if (disabled_samples.find({name_current_image, method}) != disabled_samples.end()) {
+        throw SkipTestException(name_current_image + " is disabled sample for method " + method);
+    }
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     std::vector<Point2f> corners;
     ASSERT_TRUE(qrcode.detectMulti(src, corners));
     std::vector<Mat> straight_barcode;
@@ -94,26 +101,20 @@ PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, decodeMulti)
     TEST_CYCLE()
     {
         ASSERT_TRUE(qrcode.decodeMulti(src, corners, decoded_info, straight_barcode));
-        for(size_t i = 0; i < decoded_info.size(); i++)
-        {
-            ASSERT_FALSE(decoded_info[i].empty());
-        }
+    }
+    ASSERT_TRUE(decoded_info.size() > 0ull);
+    for(size_t i = 0; i < decoded_info.size(); i++) {
+        ASSERT_FALSE(decoded_info[i].empty());
     }
     ASSERT_EQ(decoded_info.size(), straight_barcode.size());
-    vector<pair<string, Mat> > result;
-    for (size_t i = 0ull;  i < decoded_info.size(); i++) {
-        result.push_back(make_pair(decoded_info[i], straight_barcode[i]));
+    vector<Point> corners_result(corners.size());
+    for (size_t i = 0ull; i < corners_result.size(); i++) {
+        corners_result[i] = corners[i];
     }
 
-    sort(result.begin(), result.end(), compareQR);
-    vector<vector<uint8_t> > decoded_info_sort;
-    vector<Mat> straight_barcode_sort;
-    for (size_t i = 0ull;  i < result.size(); i++) {
-        vector<uint8_t> tmp(result[i].first.begin(), result[i].first.end());
-        decoded_info_sort.push_back(tmp);
-        straight_barcode_sort.push_back(result[i].second);
-    }
-    SANITY_CHECK(decoded_info_sort);
+    const int pixels_error = 7;
+    check_qr(root, name_current_image, "multiple_images", corners_result, decoded_info, pixels_error, true);
+    SANITY_CHECK_NOTHING();
 }
 #endif
 
@@ -127,11 +128,10 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode,
 // version_5_right.jpg DISABLED after tile fix, PR #22025
 
 INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode_Multi,
-    ::testing::Values(
-      "2_qrcodes.png", "3_close_qrcodes.png", "3_qrcodes.png", "4_qrcodes.png",
-      "5_qrcodes.png", "6_qrcodes.png", "7_qrcodes.png", "8_close_qrcodes.png"
-    )
-);
+    testing::Combine(testing::Values("2_qrcodes.png", "3_close_qrcodes.png", "3_qrcodes.png", "4_qrcodes.png",
+                                     "5_qrcodes.png", "6_qrcodes.png", "7_qrcodes.png", "8_close_qrcodes.png"),
+                     testing::Values("contours_based", "aruco_based")));
+
 
 typedef ::perf::TestBaseWithParam< tuple< std::string, Size > > Perf_Objdetect_Not_QRCode;
 

modules/objdetect/test/test_qr_utils.hpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test {
+
+static inline
+void check_qr(const string& root, const string& name_current_image, const string& config_name,
+                const std::vector<Point>& corners,
+                const std::vector<string>& decoded_info, const int max_pixel_error,
+                bool isMulti = false) {
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    FileNode images_list = file_config[config_name];
+    size_t images_count = static_cast<size_t>(images_list.size());
+    ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
+    for (size_t index = 0; index < images_count; index++) {
+        FileNode config = images_list[(int)index];
+        std::string name_test_image = config["image_name"];
+        if (name_test_image == name_current_image) {
+            if (isMulti) {
+                for(int j = 0; j < int(corners.size()); j += 4) {
+                    bool ok = false;
+                    for (int k = 0; k < int(corners.size() / 4); k++) {
+                        int count_eq_points = 0;
+                        for (int i = 0; i < 4; i++) {
+                            int x = config["x"][k][i];
+                            int y = config["y"][k][i];
+                            if(((abs(corners[j + i].x - x)) <= max_pixel_error) && ((abs(corners[j + i].y - y)) <= max_pixel_error))
+                              count_eq_points++;
+                        }
+                        if (count_eq_points == 4) {
+                            ok = true;
+                            break;
+                        }
+                    }
+                    EXPECT_TRUE(ok);
+                }
+            }
+            else {
+                for (int i = 0; i < (int)corners.size(); i++) {
+                    int x = config["x"][i];
+                    int y = config["y"][i];
+                    EXPECT_NEAR(x, corners[i].x, max_pixel_error);
+                    EXPECT_NEAR(y, corners[i].y, max_pixel_error);
+                }
+            }
+#ifdef HAVE_QUIRC
+            if (decoded_info.size() == 0ull)
+                return;
+            if (isMulti) {
+                size_t count_eq_info = 0;
+                for(int i = 0; i < int(decoded_info.size()); i++) {
+                    for(int j = 0; j < int(decoded_info.size()); j++) {
+                        std::string original_info = config["info"][j];
+                        if(original_info == decoded_info[i]) {
+                           count_eq_info++;
+                           break;
+                        }
+                    }
+                }
+                EXPECT_EQ(decoded_info.size(), count_eq_info);
+            }
+            else {
+                std::string original_info = config["info"];
+                EXPECT_EQ(decoded_info[0], original_info);
+            }
+#endif
+            return; // done
+        }
+    }
+    FAIL() << "Not found results for '" << name_current_image << "' image in config file:" << dataset_config <<
+              "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data.\n";
+}
+
+}

modules/objdetect/test/test_qrcode.cpp

@@ -3,6 +3,7 @@
 // of this distribution and at http://opencv.org/license.html.
 
 #include "test_precomp.hpp"
+#include "test_qr_utils.hpp"
 #include "opencv2/imgproc.hpp"
 
 namespace opencv_test { namespace {
@@ -33,6 +34,8 @@ std::string qrcode_images_multiple[] = {
   "5_qrcodes.png", "6_qrcodes.png", "7_qrcodes.png", "8_close_qrcodes.png"
 };
 
+static std::set<std::pair<std::string, std::string>> disabled_samples = {{"5_qrcodes.png", "aruco_based"}};
+
 //#define UPDATE_QRCODE_TEST_DATA
 #ifdef  UPDATE_QRCODE_TEST_DATA
 
@@ -262,43 +265,7 @@ TEST_P(Objdetect_QRCode, regression)
 #else
     ASSERT_TRUE(qrcode.detect(src, corners));
 #endif
-
-    const std::string dataset_config = findDataFile(root + "dataset_config.json");
-    FileStorage file_config(dataset_config, FileStorage::READ);
-    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
-    {
-        FileNode images_list = file_config["test_images"];
-        size_t images_count = static_cast<size_t>(images_list.size());
-        ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
-
-        for (size_t index = 0; index < images_count; index++)
-        {
-            FileNode config = images_list[(int)index];
-            std::string name_test_image = config["image_name"];
-            if (name_test_image == name_current_image)
-            {
-                for (int i = 0; i < 4; i++)
-                {
-                    int x = config["x"][i];
-                    int y = config["y"][i];
-                    EXPECT_NEAR(x, corners[i].x, pixels_error);
-                    EXPECT_NEAR(y, corners[i].y, pixels_error);
-                }
-
-#ifdef HAVE_QUIRC
-                std::string original_info = config["info"];
-                EXPECT_EQ(decoded_info, original_info);
-#endif
-
-                return; // done
-            }
-        }
-        std::cerr
-            << "Not found results for '" << name_current_image
-            << "' image in config file:" << dataset_config << std::endl
-            << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
-            << std::endl;
-    }
+    check_qr(root, name_current_image, "test_images", corners, {decoded_info}, pixels_error);
 }
 
 typedef testing::TestWithParam< std::string > Objdetect_QRCode_Close;
@@ -329,43 +296,7 @@ TEST_P(Objdetect_QRCode_Close, regression)
 #else
     ASSERT_TRUE(qrcode.detect(barcode, corners));
 #endif
-
-    const std::string dataset_config = findDataFile(root + "dataset_config.json");
-    FileStorage file_config(dataset_config, FileStorage::READ);
-    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
-    {
-        FileNode images_list = file_config["close_images"];
-        size_t images_count = static_cast<size_t>(images_list.size());
-        ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
-
-        for (size_t index = 0; index < images_count; index++)
-        {
-            FileNode config = images_list[(int)index];
-            std::string name_test_image = config["image_name"];
-            if (name_test_image == name_current_image)
-            {
-                for (int i = 0; i < 4; i++)
-                {
-                    int x = config["x"][i];
-                    int y = config["y"][i];
-                    EXPECT_NEAR(x, corners[i].x, pixels_error);
-                    EXPECT_NEAR(y, corners[i].y, pixels_error);
-                }
-
-#ifdef HAVE_QUIRC
-                std::string original_info = config["info"];
-                EXPECT_EQ(decoded_info, original_info);
-#endif
-
-                return; // done
-            }
-        }
-        std::cerr
-            << "Not found results for '" << name_current_image
-            << "' image in config file:" << dataset_config << std::endl
-            << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
-            << std::endl;
-    }
+    check_qr(root, name_current_image, "close_images", corners, {decoded_info}, pixels_error);
 }
 
 typedef testing::TestWithParam< std::string > Objdetect_QRCode_Monitor;
@@ -396,43 +327,7 @@ TEST_P(Objdetect_QRCode_Monitor, regression)
 #else
     ASSERT_TRUE(qrcode.detect(barcode, corners));
 #endif
-
-    const std::string dataset_config = findDataFile(root + "dataset_config.json");
-    FileStorage file_config(dataset_config, FileStorage::READ);
-    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
-    {
-        FileNode images_list = file_config["monitor_images"];
-        size_t images_count = static_cast<size_t>(images_list.size());
-        ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
-
-        for (size_t index = 0; index < images_count; index++)
-        {
-            FileNode config = images_list[(int)index];
-            std::string name_test_image = config["image_name"];
-            if (name_test_image == name_current_image)
-            {
-                for (int i = 0; i < 4; i++)
-                {
-                    int x = config["x"][i];
-                    int y = config["y"][i];
-                    EXPECT_NEAR(x, corners[i].x, pixels_error);
-                    EXPECT_NEAR(y, corners[i].y, pixels_error);
-                }
-
-#ifdef HAVE_QUIRC
-                std::string original_info = config["info"];
-                EXPECT_EQ(decoded_info, original_info);
-#endif
-
-                return; // done
-            }
-        }
-        std::cerr
-            << "Not found results for '" << name_current_image
-            << "' image in config file:" << dataset_config << std::endl
-            << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
-            << std::endl;
-    }
+    check_qr(root, name_current_image, "monitor_images", corners, {decoded_info}, pixels_error);
 }
 
 typedef testing::TestWithParam< std::string > Objdetect_QRCode_Curved;
@@ -458,56 +353,26 @@ TEST_P(Objdetect_QRCode_Curved, regression)
 #else
     ASSERT_TRUE(qrcode.detect(src, corners));
 #endif
-
-    const std::string dataset_config = findDataFile(root + "dataset_config.json");
-    FileStorage file_config(dataset_config, FileStorage::READ);
-    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
-    {
-        FileNode images_list = file_config["test_images"];
-        size_t images_count = static_cast<size_t>(images_list.size());
-        ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
-
-        for (size_t index = 0; index < images_count; index++)
-        {
-            FileNode config = images_list[(int)index];
-            std::string name_test_image = config["image_name"];
-            if (name_test_image == name_current_image)
-            {
-                for (int i = 0; i < 4; i++)
-                {
-                    int x = config["x"][i];
-                    int y = config["y"][i];
-                    EXPECT_NEAR(x, corners[i].x, pixels_error);
-                    EXPECT_NEAR(y, corners[i].y, pixels_error);
-                }
-
-#ifdef HAVE_QUIRC
-                std::string original_info = config["info"];
-                EXPECT_EQ(decoded_info, original_info);
-#endif
-
-                return; // done
-            }
-        }
-        std::cerr
-            << "Not found results for '" << name_current_image
-            << "' image in config file:" << dataset_config << std::endl
-            << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
-            << std::endl;
-    }
+    check_qr(root, name_current_image, "test_images", corners, {decoded_info}, pixels_error);
 }
 
-typedef testing::TestWithParam < std::string > Objdetect_QRCode_Multi;
+typedef testing::TestWithParam<std::tuple<std::string, std::string>> Objdetect_QRCode_Multi;
 TEST_P(Objdetect_QRCode_Multi, regression)
 {
-    const std::string name_current_image = GetParam();
+    const std::string name_current_image = get<0>(GetParam());
     const std::string root = "qrcode/multiple/";
+    const std::string method = get<1>(GetParam());
     const int pixels_error = 4;
 
     std::string image_path = findDataFile(root + name_current_image);
     Mat src = imread(image_path);
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
-    QRCodeDetector qrcode;
+    if (disabled_samples.find({name_current_image, method}) != disabled_samples.end())
+        throw SkipTestException(name_current_image + " is disabled sample for method " + method);
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     std::vector<Point> corners;
 #ifdef HAVE_QUIRC
     std::vector<cv::String> decoded_info;
@@ -521,75 +386,15 @@ TEST_P(Objdetect_QRCode_Multi, regression)
 #else
     ASSERT_TRUE(qrcode.detectMulti(src, corners));
 #endif
-
-    const std::string dataset_config = findDataFile(root + "dataset_config.json");
-    FileStorage file_config(dataset_config, FileStorage::READ);
-    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
-    {
-        FileNode images_list = file_config["multiple_images"];
-        size_t images_count = static_cast<size_t>(images_list.size());
-        ASSERT_GT(images_count, 0u) << "Can't find validation data entries in 'test_images': " << dataset_config;
-        for (size_t index = 0; index < images_count; index++)
-        {
-            FileNode config = images_list[(int)index];
-            std::string name_test_image = config["image_name"];
-            if (name_test_image == name_current_image)
-            {
-                for(int j = 0; j < int(corners.size()); j += 4)
-                {
-                    bool ok = false;
-                    for (int k = 0; k < int(corners.size() / 4); k++)
-                    {
-                        int count_eq_points = 0;
-                        for (int i = 0; i < 4; i++)
-                        {
-                            int x = config["x"][k][i];
-                            int y = config["y"][k][i];
-                            if(((abs(corners[j + i].x - x)) <= pixels_error) && ((abs(corners[j + i].y - y)) <= pixels_error))
-                              count_eq_points++;
-                        }
-                        if (count_eq_points == 4)
-                        {
-                            ok = true;
-                            break;
-                        }
-                    }
-                    EXPECT_TRUE(ok);
-                }
-
-#ifdef HAVE_QUIRC
-                  size_t count_eq_info = 0;
-                  for(int i = 0; i < int(decoded_info.size()); i++)
-                  {
-                      for(int j = 0; j < int(decoded_info.size()); j++)
-                      {
-                          std::string original_info = config["info"][j];
-                          if(original_info == decoded_info[i])
-                          {
-                             count_eq_info++;
-                             break;
-                          }
-                      }
-                  }
-                  EXPECT_EQ(decoded_info.size(), count_eq_info);
-#endif
-
-                  return; // done
-            }
-        }
-        std::cerr
-            << "Not found results for '" << name_current_image
-            << "' image in config file:" << dataset_config << std::endl
-            << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
-            << std::endl;
-    }
+    check_qr(root, name_current_image, "multiple_images", corners, decoded_info, pixels_error, true);
 }
 
 INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode, testing::ValuesIn(qrcode_images_name));
 INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Close, testing::ValuesIn(qrcode_images_close));
 INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Monitor, testing::ValuesIn(qrcode_images_monitor));
 INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Curved, testing::ValuesIn(qrcode_images_curved));
-INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Multi, testing::ValuesIn(qrcode_images_multiple));
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Multi, testing::Combine(testing::ValuesIn(qrcode_images_multiple),
+    testing::Values("contours_based", "aruco_based")));
 
 TEST(Objdetect_QRCode_decodeMulti, decode_regression_16491)
 {
@@ -611,8 +416,10 @@ TEST(Objdetect_QRCode_decodeMulti, decode_regression_16491)
 #endif
 }
 
-TEST(Objdetect_QRCode_detectMulti, detect_regression_16961)
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_detectMulti;
+TEST_P(Objdetect_QRCode_detectMulti, detect_regression_16961)
 {
+    const std::string method = GetParam();
     const std::string name_current_image = "9_qrcodes.jpg";
     const std::string root = "qrcode/multiple/";
 
@@ -620,7 +427,10 @@ TEST(Objdetect_QRCode_detectMulti, detect_regression_16961)
     Mat src = imread(image_path);
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
 
-    QRCodeDetector qrcode;
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     std::vector<Point> corners;
     EXPECT_TRUE(qrcode.detectMulti(src, corners));
     ASSERT_FALSE(corners.empty());
@@ -628,21 +438,27 @@ TEST(Objdetect_QRCode_detectMulti, detect_regression_16961)
     EXPECT_EQ(corners.size(), expect_corners_size);
 }
 
-TEST(Objdetect_QRCode_decodeMulti, check_output_parameters_type_19363)
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_detectMulti, testing::Values("contours_based", "aruco_based"));
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_detectAndDecodeMulti;
+TEST_P(Objdetect_QRCode_detectAndDecodeMulti, check_output_parameters_type_19363)
 {
     const std::string name_current_image = "9_qrcodes.jpg";
     const std::string root = "qrcode/multiple/";
+    const std::string method = GetParam();
 
     std::string image_path = findDataFile(root + name_current_image);
     Mat src = imread(image_path);
     ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
 #ifdef HAVE_QUIRC
-    QRCodeDetector qrcode;
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     std::vector<Point> corners;
     std::vector<cv::String> decoded_info;
 #if 0  // FIXIT: OutputArray::create() type check
     std::vector<Mat2b> straight_barcode_nchannels;
-    EXPECT_ANY_THROW(qrcode.detectAndDecodeMulti(src, decoded_info, corners, straight_barcode_nchannels));
+    EXPECT_ANY_THROW(qrcode->detectAndDecodeMulti(src, decoded_info, corners, straight_barcode_nchannels));
 #endif
 
     int expected_barcode_type = CV_8UC1;
@@ -653,6 +469,8 @@ TEST(Objdetect_QRCode_decodeMulti, check_output_parameters_type_19363)
         EXPECT_EQ(expected_barcode_type, straight_barcode[i].type());
 #endif
 }
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_detectAndDecodeMulti, testing::Values("contours_based", "aruco_based"));
+
 
 TEST(Objdetect_QRCode_detect, detect_regression_20882)
 {
@@ -793,14 +611,18 @@ TEST(Objdetect_QRCode_decode, decode_regression_version_25)
 #endif
 }
 
-TEST(Objdetect_QRCode_decodeMulti, decode_9_qrcodes_version7)
+TEST_P(Objdetect_QRCode_detectAndDecodeMulti, decode_9_qrcodes_version7)
 {
     const std::string name_current_image = "9_qrcodes_version7.jpg";
     const std::string root = "qrcode/multiple/";
 
     std::string image_path = findDataFile(root + name_current_image);
     Mat src = imread(image_path);
-    QRCodeDetector qrcode;
+    const std::string method = GetParam();
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
     std::vector<Point> corners;
     std::vector<cv::String> decoded_info;
 

samples/cpp/qrcode.cpp

@@ -12,6 +12,7 @@ using namespace cv;
 static int liveQRCodeDetect();
 static int imageQRCodeDetect(const string& in_file);
 
+static bool g_useArucoBased = false;
 static bool g_modeMultiQR = false;
 static bool g_detectOnly = false;
 
@@ -35,6 +36,7 @@ int main(int argc, char *argv[])
     const string keys =
         "{h help ? |        | print help messages }"
         "{i in     |        | input image path (also switches to image detection mode) }"
+        "{aruco_based | false | use Aruco-based QR code detector instead of contour-based }"
         "{detect   | false  | detect QR code only (skip decoding) }"
         "{m multi  |        | use detect for multiple qr-codes }"
         "{o out    | qr_code.png | path to result file }"
@@ -75,6 +77,7 @@ int main(int argc, char *argv[])
 
     g_modeMultiQR = cmd_parser.has("multi") && cmd_parser.get<bool>("multi");
     g_detectOnly = cmd_parser.has("detect") && cmd_parser.get<bool>("detect");
+    g_useArucoBased = cmd_parser.has("aruco_based") && cmd_parser.get<bool>("aruco_based");
 
     g_saveDetections = cmd_parser.has("save_detections") && cmd_parser.get<bool>("save_detections");
     g_saveAll = cmd_parser.has("save_all") && cmd_parser.get<bool>("save_all");
@@ -157,7 +160,7 @@ void drawQRCodeResults(Mat& frame, const vector<Point>& corners, const vector<cv
 
 static
 void runQR(
-    QRCodeDetector& qrcode, const Mat& input,
+    const QRCodeDetectorBase& qrcode, const Mat& input,
     vector<Point>& corners, vector<cv::String>& decode_info
     // +global: bool g_modeMultiQR, bool g_detectOnly
 )
@@ -191,7 +194,7 @@ void runQR(
 }
 
 static
-double processQRCodeDetection(QRCodeDetector& qrcode, const Mat& input, Mat& result, vector<Point>& corners)
+double processQRCodeDetection(const QRCodeDetectorBase& qrcode, const Mat& input, Mat& result, vector<Point>& corners)
 {
     if (input.channels() == 1)
         cvtColor(input, result, COLOR_GRAY2BGR);
@@ -229,7 +232,9 @@ int liveQRCodeDetect()
     cout << "Press 'd' to switch between decoder and detector" << endl;
     cout << "Press ' ' (space) to save result into images" << endl;
     cout << "Press 'ESC' to exit" << endl;
-    QRCodeDetector qrcode;
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (g_useArucoBased)
+        qrcode = QRCodeDetectorAruco();
 
     for (;;)
     {
@@ -310,7 +315,10 @@ int imageQRCodeDetect(const string& in_file)
         << " on image: " << input.size() << " (" << typeToString(input.type()) << ")"
         << endl;
 
-    QRCodeDetector qrcode;
+    QRCodeDetectorBase qrcode = QRCodeDetector();
+    if (g_useArucoBased)
+        qrcode = QRCodeDetectorAruco();
+
     vector<Point> corners;
     vector<cv::String> decode_info;