ChArUco unit tests adapted to support legacy switch.

Author: stefan523

modules/aruco/include/opencv2/aruco/charuco.hpp

@@ -116,6 +116,11 @@ class CV_EXPORTS_W CharucoBoard : public Board {
       */
     CV_WRAP float getMarkerLength() const { return _markerLength; }
 
+    /**
+      *
+      */
+    CV_WRAP bool getLegacyFlag() const { return _legacy; }
+
     private:
     void _getNearestMarkerCorners();
 

modules/aruco/test/test_aruco_utils.hpp

@@ -6,13 +6,13 @@ namespace opencv_test {
 namespace {
 
 static inline vector<Point2f> getAxis(InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _rvec,
-                                      InputArray _tvec, float length, const float offset = 0.f)
+                                      InputArray _tvec, float length, const Point2f offset = Point2f(0, 0))
 {
     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;

modules/aruco/test/test_charucodetection.cpp

@@ -46,15 +46,19 @@ namespace opencv_test { namespace {
  * @brief Get a synthetic image of Chessboard in perspective
  */
 static Mat projectChessboard(int squaresX, int squaresY, float squareSize, Size imageSize,
-                             Mat cameraMatrix, Mat rvec, Mat tvec) {
+                             Mat cameraMatrix, Mat rvec, Mat tvec, bool legacy) {
 
     Mat img(imageSize, CV_8UC1, Scalar::all(255));
     Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
 
     for(int y = 0; y < squaresY; y++) {
         float startY = float(y) * squareSize;
         for(int x = 0; x < squaresX; x++) {
-            if(y % 2 != x % 2) continue;
+            if(legacy) {
+                if((y + ((squaresY + 1) % 2)) % 2 != x % 2) continue;
+            } else {
+                if(y % 2 != x % 2) continue;
+            }
             float startX = float(x) * squareSize;
 
             vector< Point3f > squareCorners;
@@ -101,7 +105,7 @@ static Mat projectCharucoBoard(Ptr<aruco::CharucoBoard> &board, Mat cameraMatrix
     // project chessboard
     Mat chessboard =
         projectChessboard(board->getChessboardSize().width, board->getChessboardSize().height,
-                          board->getSquareLength(), imageSize, cameraMatrix, rvec, tvec);
+                          board->getSquareLength(), imageSize, cameraMatrix, rvec, tvec, board->getLegacyFlag());
 
     for(unsigned int i = 0; i < chessboard.total(); i++) {
         if(chessboard.ptr< unsigned char >()[i] == 0) {
@@ -130,84 +134,85 @@ CV_CharucoDetection::CV_CharucoDetection() {}
 void CV_CharucoDetection::run(int) {
 
     int iter = 0;
-    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
     Size imgSize(500, 500);
-    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
-    Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.03f, 0.015f, dictionary);
-
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
     cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 600;
     cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
     cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
-
     Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
 
-    // for different perspectives
-    for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
-        for(int yaw = -55; yaw <= 50; yaw += 25) {
-            for(int pitch = -55; pitch <= 50; pitch += 25) {
-
-                int markerBorder = iter % 2 + 1;
-                iter++;
-
-                // create synthetic image
-                Mat rvec, tvec;
-                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
-                                              distance, imgSize, markerBorder, rvec, tvec);
-
-                // detect markers
-                vector< vector< Point2f > > corners;
-                vector< int > ids;
-                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
-                params->minDistanceToBorder = 3;
-                params->markerBorderBits = markerBorder;
-                aruco::detectMarkers(img, dictionary, corners, ids, params);
-
-                if(ids.size() == 0) {
-                    ts->printf(cvtest::TS::LOG, "Marker detection failed");
-                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
-                    return;
-                }
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    for(bool legacy : {true, false}) {
+        Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.04f, 0.03f, dictionary, legacy);
+
+        // for different perspectives
+        for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
+            for(int yaw = -55; yaw <= 50; yaw += 25) {
+                for(int pitch = -55; pitch <= 50; pitch += 25) {
+
+                    int markerBorder = iter % 2 + 1;
+                    iter++;
+
+                    // create synthetic image
+                    Mat rvec, tvec;
+                    Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                                distance, imgSize, markerBorder, rvec, tvec);
+
+                    // detect markers
+                    vector< vector< Point2f > > corners;
+                    vector< int > ids;
+                    Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                    params->minDistanceToBorder = 3;
+                    params->markerBorderBits = markerBorder;
+                    aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                    if(ids.size() == 0) {
+                        ts->printf(cvtest::TS::LOG, "Marker detection failed");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
 
-                // interpolate charuco corners
-                vector< Point2f > charucoCorners;
-                vector< int > charucoIds;
+                    // interpolate charuco corners
+                    vector< Point2f > charucoCorners;
+                    vector< int > charucoIds;
 
-                if(iter % 2 == 0) {
-                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
-                                                     charucoIds);
-                } else {
-                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
-                                                     charucoIds, cameraMatrix, distCoeffs);
-                }
+                    if(iter % 2 == 0) {
+                        aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                        charucoIds);
+                    } else {
+                        aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                        charucoIds, cameraMatrix, distCoeffs);
+                    }
 
-                // check results
-                vector< Point2f > projectedCharucoCorners;
+                    // check results
+                    vector< Point2f > projectedCharucoCorners;
 
-                // copy chessboardCorners
-                vector<Point3f> copyChessboardCorners = board->chessboardCorners;
-                // move copyChessboardCorners points
-                for (size_t i = 0; i < copyChessboardCorners.size(); i++)
-                    copyChessboardCorners[i] -= board->rightBottomBorder / 2.f;
-                projectPoints(copyChessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
-                              projectedCharucoCorners);
+                    // copy chessboardCorners
+                    vector<Point3f> copyChessboardCorners = board->chessboardCorners;
+                    // move copyChessboardCorners points
+                    for (size_t i = 0; i < copyChessboardCorners.size(); i++)
+                        copyChessboardCorners[i] -= board->rightBottomBorder / 2.f;
+                    projectPoints(copyChessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                                projectedCharucoCorners);
 
-                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+                    for(unsigned int i = 0; i < charucoIds.size(); i++) {
 
-                    int currentId = charucoIds[i];
+                        int currentId = charucoIds[i];
 
-                    if(currentId >= (int)board->chessboardCorners.size()) {
-                        ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
-                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
-                        return;
-                    }
+                        if(currentId >= (int)board->chessboardCorners.size()) {
+                            ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
 
-                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+                        double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
 
 
-                    if(repError > 5.) {
-                        ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
-                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
-                        return;
+                        if(repError > 5.) {
+                            ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
                     }
                 }
             }
@@ -235,91 +240,101 @@ CV_CharucoPoseEstimation::CV_CharucoPoseEstimation() {}
 void CV_CharucoPoseEstimation::run(int) {
 
     int iter = 0;
+    Size imgSize(750, 750);
     Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
-    Size imgSize(500, 500);
-    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
-    Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.03f, 0.015f, dictionary);
-
     cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
     cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
     cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
-
     Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
-    // for different perspectives
-    for(double distance = 0.2; distance <= 0.3; distance += 0.1) {
-        for(int yaw = -55; yaw <= 50; yaw += 25) {
-            for(int pitch = -55; pitch <= 50; pitch += 25) {
-
-                int markerBorder = iter % 2 + 1;
-                iter++;
-
-                // get synthetic image
-                Mat rvec, tvec;
-                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
-                                              distance, imgSize, markerBorder, rvec, tvec);
-
-                // detect markers
-                vector< vector< Point2f > > corners;
-                vector< int > ids;
-                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
-                params->minDistanceToBorder = 3;
-                params->markerBorderBits = markerBorder;
-                aruco::detectMarkers(img, dictionary, corners, ids, params);
-
-                ASSERT_EQ(ids.size(), board->ids.size());
-
-                // interpolate charuco corners
-                vector< Point2f > charucoCorners;
-                vector< int > charucoIds;
-
-                if(iter % 2 == 0) {
-                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
-                                                     charucoIds);
-                } else {
-                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
-                                                     charucoIds, cameraMatrix, distCoeffs);
-                }
-
-                if(charucoIds.size() == 0) continue;
-
-                // estimate charuco pose
-                aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix,
-                                                distCoeffs, rvec, tvec);
 
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    for(bool legacy : {true, false}) {
+        Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.04f, 0.03f, dictionary, legacy);
+
+        // for different perspectives
+        for(double distance = 0.2; distance <= 0.3; distance += 0.1) {
+            for(int yaw = -55; yaw <= 50; yaw += 25) {
+                for(int pitch = -55; pitch <= 50; pitch += 25) {
+
+                    int markerBorder = iter % 2 + 1;
+                    iter++;
+
+                    // get synthetic image
+                    Mat rvec, tvec;
+                    Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                                distance, imgSize, markerBorder, rvec, tvec);
+
+                    // detect markers
+                    vector< vector< Point2f > > corners;
+                    vector< int > ids;
+                    Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                    params->minDistanceToBorder = 3;
+                    params->markerBorderBits = markerBorder;
+                    aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                    ASSERT_EQ(ids.size(), board->ids.size());
+
+                    // interpolate charuco corners
+                    vector< Point2f > charucoCorners;
+                    vector< int > charucoIds;
+
+                    if(iter % 2 == 0) {
+                        aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                        charucoIds);
+                    } else {
+                        aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                        charucoIds, cameraMatrix, distCoeffs);
+                    }
 
-                // check axes
-                const float offset = (board->getSquareLength() - board->getMarkerLength()) / 2.f;
-                vector<Point2f> axes = getAxis(cameraMatrix, distCoeffs, rvec, tvec, board->getSquareLength(), offset);
-                vector<Point2f> topLeft = getMarkerById(board->ids[0], corners, ids);
-                ASSERT_NEAR(topLeft[0].x, axes[1].x, 3.f);
-                ASSERT_NEAR(topLeft[0].y, axes[1].y, 3.f);
-                vector<Point2f> bottomLeft = getMarkerById(board->ids[2], corners, ids);
-                ASSERT_NEAR(bottomLeft[0].x, axes[2].x, 3.f);
-                ASSERT_NEAR(bottomLeft[0].y, axes[2].y, 3.f);
+                    if(charucoIds.size() == 0) continue;
+
+                    // estimate charuco pose
+                    aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix,
+                                                    distCoeffs, rvec, tvec);
+
+                    // check axes
+                    const float aruco_offset = (board->getSquareLength() - board->getMarkerLength()) / 2.f;
+                    Point2f offset;
+                    vector<Point2f> topLeft, bottomLeft;
+                    if(legacy && (board->getChessboardSize().height % 2 == 0)) { // legacy and even row count
+                        offset = Point2f(aruco_offset + board->getSquareLength(), aruco_offset);
+                        topLeft = getMarkerById(board->ids[1], corners, ids);
+                        bottomLeft = getMarkerById(board->ids[2], corners, ids);
+                    } else {
+                        offset = Point2f(aruco_offset, aruco_offset);
+                        topLeft = getMarkerById(board->ids[0], corners, ids);
+                        bottomLeft = getMarkerById(board->ids[2], corners, ids);
+                    }
+                    vector<Point2f> axes = getAxis(cameraMatrix, distCoeffs, rvec, tvec, board->getSquareLength(), offset);
+                    ASSERT_NEAR(topLeft[0].x, axes[1].x, 3.f);
+                    ASSERT_NEAR(topLeft[0].y, axes[1].y, 3.f);
+                    ASSERT_NEAR(bottomLeft[0].x, axes[2].x, 3.f);
+                    ASSERT_NEAR(bottomLeft[0].y, axes[2].y, 3.f);
 
-                // check estimate result
-                vector< Point2f > projectedCharucoCorners;
+                    // check estimate result
+                    vector< Point2f > projectedCharucoCorners;
 
-                projectPoints(board->chessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
-                              projectedCharucoCorners);
+                    projectPoints(board->chessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                                projectedCharucoCorners);
 
-                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+                    for(unsigned int i = 0; i < charucoIds.size(); i++) {
 
-                    int currentId = charucoIds[i];
+                        int currentId = charucoIds[i];
 
-                    if(currentId >= (int)board->chessboardCorners.size()) {
-                        ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
-                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
-                        return;
-                    }
+                        if(currentId >= (int)board->chessboardCorners.size()) {
+                            ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
 
-                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+                        double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
 
 
-                    if(repError > 5.) {
-                        ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
-                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
-                        return;
+                        if(repError > 5.) {
+                            ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
                     }
                 }
             }