Merge pull request #23153 from stefan523:ChArUco_pre460_pattern_support

asmorkalov · web-flow · commit 6160104fd796 · 2023-05-04T18:30:40.000+03:00
ChArUco pre460 pattern support
diff --git a/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp b/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp
@@ -146,6 +146,18 @@ class CV_EXPORTS_W_SIMPLE CharucoBoard : public Board {
     CV_WRAP CharucoBoard(const Size& size, float squareLength, float markerLength,
                          const Dictionary &dictionary, InputArray ids = noArray());
 
+    /** @brief set legacy chessboard pattern.
+     *
+     * Legacy setting creates chessboard patterns starting with a white box in the upper left corner
+     * if there is an even row count of chessboard boxes, otherwise it starts with a black box.
+     * This setting ensures compatibility to patterns created with OpenCV versions prior OpenCV 4.6.0.
+     * See https://github.com/opencv/opencv/issues/23152.
+     *
+     * Default value: false.
+     */
+    CV_WRAP void setLegacyPattern(bool legacyPattern);
+    CV_WRAP bool getLegacyPattern() const;
+
     CV_WRAP Size getChessboardSize() const;
     CV_WRAP float getSquareLength() const;
     CV_WRAP float getMarkerLength() const;
diff --git a/modules/objdetect/src/aruco/aruco_board.cpp b/modules/objdetect/src/aruco/aruco_board.cpp
@@ -229,7 +229,8 @@ struct GridBoardImpl : public Board::Impl {
         Board::Impl(_dictionary),
         size(_size),
         markerLength(_markerLength),
-        markerSeparation(_markerSeparation)
+        markerSeparation(_markerSeparation),
+        legacyPattern(false)
     {
         CV_Assert(size.width*size.height > 0 && markerLength > 0 && markerSeparation > 0);
     }
@@ -240,6 +241,8 @@ struct GridBoardImpl : public Board::Impl {
     float markerLength;
     // separation between markers in the grid
     float markerSeparation;
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
 };
 
 GridBoard::GridBoard() {}
@@ -297,7 +300,8 @@ struct CharucoBoardImpl : Board::Impl {
         Board::Impl(_dictionary),
         size(_size),
         squareLength(_squareLength),
-        markerLength(_markerLength)
+        markerLength(_markerLength),
+        legacyPattern(false)
     {}
 
     // chessboard size
@@ -309,13 +313,17 @@ struct CharucoBoardImpl : Board::Impl {
     // Physical marker side length (normally in meters)
     float markerLength;
 
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
+
     // vector of chessboard 3D corners precalculated
     std::vector<Point3f> chessboardCorners;
 
     // for each charuco corner, nearest marker id and nearest marker corner id of each marker
     std::vector<std::vector<int> > nearestMarkerIdx;
     std::vector<std::vector<int> > nearestMarkerCorners;
 
+    void createCharucoBoard();
     void calcNearestMarkerCorners();
 
     void matchImagePoints(InputArrayOfArrays detectedCharuco, InputArray detectedIds,
@@ -324,8 +332,56 @@ struct CharucoBoardImpl : Board::Impl {
     void generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const override;
 };
 
+void CharucoBoardImpl::createCharucoBoard() {
+    float diffSquareMarkerLength = (squareLength - markerLength) / 2;
+    int totalMarkers = (int)(ids.size());
+    // calculate Board objPoints
+    int nextId = 0;
+    objPoints.clear();
+    for(int y = 0; y < size.height; y++) {
+        for(int x = 0; x < size.width; x++) {
+
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 == x % 2) continue; // black corner, no marker here
+            } else {
+                if(y % 2 == x % 2) continue; // black corner, no marker here
+            }
+
+            vector<Point3f> corners(4);
+            corners[0] = Point3f(x * squareLength + diffSquareMarkerLength,
+                                 y * squareLength + diffSquareMarkerLength, 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, markerLength, 0);
+            objPoints.push_back(corners);
+            // first ids in dictionary
+            if (totalMarkers == 0)
+                ids.push_back(nextId);
+            nextId++;
+        }
+    }
+    if (totalMarkers > 0 && nextId != totalMarkers)
+        CV_Error(cv::Error::StsBadSize, "Size of ids must be equal to the number of markers: "+std::to_string(nextId));
+
+    // now fill chessboardCorners
+    chessboardCorners.clear();
+    for(int y = 0; y < size.height - 1; y++) {
+        for(int x = 0; x < size.width - 1; x++) {
+            Point3f corner;
+            corner.x = (x + 1) * squareLength;
+            corner.y = (y + 1) * squareLength;
+            corner.z = 0;
+            chessboardCorners.push_back(corner);
+        }
+    }
+    rightBottomBorder = Point3f(size.width * squareLength, size.height * squareLength, 0.f);
+    calcNearestMarkerCorners();
+}
+
 /** Fill nearestMarkerIdx and nearestMarkerCorners arrays */
 void CharucoBoardImpl::calcNearestMarkerCorners() {
+    nearestMarkerIdx.clear();
+    nearestMarkerCorners.clear();
     nearestMarkerIdx.resize(chessboardCorners.size());
     nearestMarkerCorners.resize(chessboardCorners.size());
     unsigned int nMarkers = (unsigned int)objPoints.size();
@@ -459,7 +515,11 @@ void CharucoBoardImpl::generateImage(Size outSize, OutputArray img, int marginSi
     for(int y = 0; y < size.height; y++) {
         for(int x = 0; x < size.width; x++) {
 
-            if(y % 2 != x % 2) continue; // white corner, dont do anything
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 != x % 2) continue; // white corner, dont do anything
+            } else {
+                if(y % 2 != x % 2) continue; // white corner, dont do anything
+            }
 
             double startX, startY;
             startX = squareSizePixels * double(x);
@@ -481,47 +541,9 @@ CharucoBoard::CharucoBoard(const Size& size, float squareLength, float markerLen
 
     CV_Assert(size.width > 1 && size.height > 1 && markerLength > 0 && squareLength > markerLength);
 
-    vector<vector<Point3f> > objPoints;
-    float diffSquareMarkerLength = (squareLength - markerLength) / 2;
-    int totalMarkers = (int)(ids.total());
     ids.copyTo(impl->ids);
-    // calculate Board objPoints
-    int nextId = 0;
-    for(int y = 0; y < size.height; y++) {
-        for(int x = 0; x < size.width; x++) {
-
-            if(y % 2 == x % 2) continue; // black corner, no marker here
-
-            vector<Point3f> corners(4);
-            corners[0] = Point3f(x * squareLength + diffSquareMarkerLength,
-                                 y * squareLength + diffSquareMarkerLength, 0);
-            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
-            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
-            corners[3] = corners[0] + Point3f(0, markerLength, 0);
-            objPoints.push_back(corners);
-            // first ids in dictionary
-            if (totalMarkers == 0)
-                impl->ids.push_back(nextId);
-            nextId++;
-        }
-    }
-    if (totalMarkers > 0 && nextId != totalMarkers)
-        CV_Error(cv::Error::StsBadSize, "Size of ids must be equal to the number of markers: "+std::to_string(nextId));
-    impl->objPoints = objPoints;
 
-    // now fill chessboardCorners
-    std::vector<Point3f> & c = static_pointer_cast<CharucoBoardImpl>(impl)->chessboardCorners;
-    for(int y = 0; y < size.height - 1; y++) {
-        for(int x = 0; x < size.width - 1; x++) {
-            Point3f corner;
-            corner.x = (x + 1) * squareLength;
-            corner.y = (y + 1) * squareLength;
-            corner.z = 0;
-            c.push_back(corner);
-        }
-    }
-    impl->rightBottomBorder = Point3f(size.width * squareLength, size.height * squareLength, 0.f);
-    static_pointer_cast<CharucoBoardImpl>(impl)->calcNearestMarkerCorners();
+    static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
 }
 
 Size CharucoBoard::getChessboardSize() const {
@@ -539,6 +561,20 @@ float CharucoBoard::getMarkerLength() const {
     return static_pointer_cast<CharucoBoardImpl>(impl)->markerLength;
 }
 
+void CharucoBoard::setLegacyPattern(bool legacyPattern) {
+    CV_Assert(impl);
+    if (static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern != legacyPattern)
+    {
+        static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern = legacyPattern;
+        static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
+    }
+}
+
+bool CharucoBoard::getLegacyPattern() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern;
+}
+
 bool CharucoBoard::checkCharucoCornersCollinear(InputArray charucoIds) const {
     CV_Assert(impl);
     Mat charucoIdsMat = charucoIds.getMat();
diff --git a/modules/objdetect/test/test_aruco_utils.cpp b/modules/objdetect/test/test_aruco_utils.cpp
@@ -8,12 +8,12 @@
 namespace opencv_test {
 
 vector<Point2f> getAxis(InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _rvec,
-                        InputArray _tvec, float length, const float offset) {
+                        InputArray _tvec, float length, const Point2f offset) {
     vector<Point3f> axis;
-    axis.push_back(Point3f(offset, offset, 0.f));
-    axis.push_back(Point3f(length+offset, offset, 0.f));
-    axis.push_back(Point3f(offset, length+offset, 0.f));
-    axis.push_back(Point3f(offset, offset, length));
+    axis.push_back(Point3f(offset.x, offset.y, 0.f));
+    axis.push_back(Point3f(length+offset.x, offset.y, 0.f));
+    axis.push_back(Point3f(offset.x, length+offset.y, 0.f));
+    axis.push_back(Point3f(offset.x, offset.y, length));
     vector<Point2f> axis_to_img;
     projectPoints(axis, _rvec, _tvec, _cameraMatrix, _distCoeffs, axis_to_img);
     return axis_to_img;
diff --git a/modules/objdetect/test/test_aruco_utils.hpp b/modules/objdetect/test/test_aruco_utils.hpp
@@ -10,7 +10,7 @@ namespace opencv_test {
 static inline double deg2rad(double deg) { return deg * CV_PI / 180.; }
 
 vector<Point2f> getAxis(InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _rvec, InputArray _tvec,
-                        float length, const float offset = 0.f);
+                        float length, const Point2f offset = Point2f(0, 0));
 
 vector<Point2f> getMarkerById(int id, const vector<vector<Point2f> >& corners, const vector<int>& ids);
 
diff --git a/modules/objdetect/test/test_charucodetection.cpp b/modules/objdetect/test/test_charucodetection.cpp
