Merge pull request #25378 from AleksandrPanov:move_charuco_tutorial

Move Charuco/Calib tutorials and samples to main repo #25378 Merge with https://github.com/opencv/opencv_contrib/pull/3708 Move Charuco/Calib tutorials and samples to main repo: - [x] update/fix charuco_detection.markdown and samples - [x] update/fix charuco_diamond_detection.markdown and samples - [x] update/fix aruco_calibration.markdown and samples - [x] update/fix aruco_faq.markdown - [x] move tutorials, samples and tests to main repo - [x] remove old tutorials, samples and tests from contrib ### 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 - [x] 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
2026-07-24 21:03:03 +04:00 · 2024-04-16 12:14:33 +03:00
parent 4fb0541916
commit e2621f128e
33 changed files with 1947 additions and 137 deletions
@@ -45,4 +45,47 @@ inline static bool saveCameraParams(const std::string &filename, cv::Size imageS
    return true;
 }

+inline static cv::aruco::DetectorParameters readDetectorParamsFromCommandLine(cv::CommandLineParser &parser) {
+    cv::aruco::DetectorParameters detectorParams;
+    if (parser.has("dp")) {
+        cv::FileStorage fs(parser.get<std::string>("dp"), cv::FileStorage::READ);
+        bool readOk = detectorParams.readDetectorParameters(fs.root());
+        if(!readOk) {
+            throw std::runtime_error("Invalid detector parameters file\n");
+        }
+    }
+    return detectorParams;
+}
+
+inline static void readCameraParamsFromCommandLine(cv::CommandLineParser &parser, cv::Mat& camMatrix, cv::Mat& distCoeffs) {
+    //! [camDistCoeffs]
+    if(parser.has("c")) {
+        bool readOk = readCameraParameters(parser.get<std::string>("c"), camMatrix, distCoeffs);
+        if(!readOk) {
+            throw std::runtime_error("Invalid camera file\n");
+        }
+    }
+    //! [camDistCoeffs]
+}
+
+inline static cv::aruco::Dictionary readDictionatyFromCommandLine(cv::CommandLineParser &parser) {
+    cv::aruco::Dictionary dictionary;
+    if (parser.has("cd")) {
+        cv::FileStorage fs(parser.get<std::string>("cd"), cv::FileStorage::READ);
+        bool readOk = dictionary.readDictionary(fs.root());
+        if(!readOk) {
+            throw std::runtime_error("Invalid dictionary file\n");
+        }
+    }
+    else {
+        int dictionaryId = parser.has("d") ? parser.get<int>("d"): cv::aruco::DICT_4X4_50;
+        if (!parser.has("d")) {
+            std::cout << "The default DICT_4X4_50 dictionary has been selected, you could "
+                         "select the specific dictionary using flags -d or -cd." << std::endl;
+        }
+        dictionary = cv::aruco::getPredefinedDictionary(dictionaryId);
+    }
+    return dictionary;
+}
+
 }
@@ -0,0 +1,188 @@
+#include <ctime>
+#include <iostream>
+#include <vector>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect/aruco_detector.hpp>
+#include "aruco_samples_utility.hpp"
+
+using namespace std;
+using namespace cv;
+
+
+namespace {
+const char* about =
+        "Calibration using a ArUco Planar Grid board\n"
+        "  To capture a frame for calibration, press 'c',\n"
+        "  If input comes from video, press any key for next frame\n"
+        "  To finish capturing, press 'ESC' key and calibration starts.\n";
+const char* keys  =
+        "{w        |       | Number of squares in X direction }"
+        "{h        |       | Number of squares in Y direction }"
+        "{l        |       | Marker side length (in meters) }"
+        "{s        |       | Separation between two consecutive markers in the grid (in meters) }"
+        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{cd       |       | Input file with custom dictionary }"
+        "{@outfile |cam.yml| Output file with calibrated camera parameters }"
+        "{v        |       | Input from video file, if ommited, input comes from camera }"
+        "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
+        "{dp       |       | File of marker detector parameters }"
+        "{rs       | false | Apply refind strategy }"
+        "{zt       | false | Assume zero tangential distortion }"
+        "{a        |       | Fix aspect ratio (fx/fy) to this value }"
+        "{pc       | false | Fix the principal point at the center }";
+}
+
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 6) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int markersX = parser.get<int>("w");
+    int markersY = parser.get<int>("h");
+    float markerLength = parser.get<float>("l");
+    float markerSeparation = parser.get<float>("s");
+    string outputFile = parser.get<string>(0);
+
+    int calibrationFlags = 0;
+    float aspectRatio = 1;
+    if(parser.has("a")) {
+        calibrationFlags |= CALIB_FIX_ASPECT_RATIO;
+        aspectRatio = parser.get<float>("a");
+    }
+    if(parser.get<bool>("zt")) calibrationFlags |= CALIB_ZERO_TANGENT_DIST;
+    if(parser.get<bool>("pc")) calibrationFlags |= CALIB_FIX_PRINCIPAL_POINT;
+
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
+
+    bool refindStrategy = parser.get<bool>("rs");
+    int camId = parser.get<int>("ci");
+    String video;
+
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(!video.empty()) {
+        inputVideo.open(video);
+        waitTime = 0;
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    //! [CalibrationWithArucoBoard1]
+    // Create board object and ArucoDetector
+    aruco::GridBoard gridboard(Size(markersX, markersY), markerLength, markerSeparation, dictionary);
+    aruco::ArucoDetector detector(dictionary, detectorParams);
+
+    // Collected frames for calibration
+    vector<vector<vector<Point2f>>> allMarkerCorners;
+    vector<vector<int>> allMarkerIds;
+    Size imageSize;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        vector<int> markerIds;
+        vector<vector<Point2f>> markerCorners, rejectedMarkers;
+
+        // Detect markers
+        detector.detectMarkers(image, markerCorners, markerIds, rejectedMarkers);
+
+        // Refind strategy to detect more markers
+        if(refindStrategy) {
+            detector.refineDetectedMarkers(image, gridboard, markerCorners, markerIds, rejectedMarkers);
+        }
+        //! [CalibrationWithArucoBoard1]
+
+        // Draw results
+        image.copyTo(imageCopy);
+
+        if(!markerIds.empty()) {
+            aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
+        }
+
+        putText(imageCopy, "Press 'c' to add current frame. 'ESC' to finish and calibrate",
+                Point(10, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 0), 2);
+        imshow("out", imageCopy);
+
+        // Wait for key pressed
+        char key = (char)waitKey(waitTime);
+
+        if(key == 27) {
+             break;
+        }
+
+        //! [CalibrationWithArucoBoard2]
+        if(key == 'c' && !markerIds.empty()) {
+            cout << "Frame captured" << endl;
+            allMarkerCorners.push_back(markerCorners);
+            allMarkerIds.push_back(markerIds);
+            imageSize = image.size();
+        }
+    }
+    //! [CalibrationWithArucoBoard2]
+
+    if(allMarkerIds.empty()) {
+        throw std::runtime_error("Not enough captures for calibration\n");
+    }
+
+    //! [CalibrationWithArucoBoard3]
+    Mat cameraMatrix, distCoeffs;
+
+    if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
+        cameraMatrix = Mat::eye(3, 3, CV_64F);
+        cameraMatrix.at<double>(0, 0) = aspectRatio;
+    }
+
+    // Prepare data for calibration
+    vector<Point3f> objectPoints;
+    vector<Point2f> imagePoints;
+    vector<Mat> processedObjectPoints, processedImagePoints;
+    size_t nFrames = allMarkerCorners.size();
+
+    for(size_t frame = 0; frame < nFrames; frame++) {
+        Mat currentImgPoints, currentObjPoints;
+
+        gridboard.matchImagePoints(allMarkerCorners[frame], allMarkerIds[frame], currentObjPoints, currentImgPoints);
+
+        if(currentImgPoints.total() > 0 && currentObjPoints.total() > 0) {
+            processedImagePoints.push_back(currentImgPoints);
+            processedObjectPoints.push_back(currentObjPoints);
+        }
+    }
+
+    // Calibrate camera
+    double repError = calibrateCamera(processedObjectPoints, processedImagePoints, imageSize, cameraMatrix, distCoeffs,
+                                      noArray(), noArray(), noArray(), noArray(), noArray(), calibrationFlags);
+    //! [CalibrationWithArucoBoard3]
+    bool saveOk = saveCameraParams(outputFile, imageSize, aspectRatio, calibrationFlags,
+                                   cameraMatrix, distCoeffs, repError);
+
+    if(!saveOk) {
+        throw std::runtime_error("Cannot save output file\n");
+    }
+
+    cout << "Rep Error: " << repError << endl;
+    cout << "Calibration saved to " << outputFile << endl;
+    return 0;
+}
@@ -0,0 +1,216 @@
+#include <iostream>
+#include <vector>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect/charuco_detector.hpp>
+#include "aruco_samples_utility.hpp"
+
+using namespace std;
+using namespace cv;
+
+namespace {
+const char* about =
+        "Calibration using a ChArUco board\n"
+        "  To capture a frame for calibration, press 'c',\n"
+        "  If input comes from video, press any key for next frame\n"
+        "  To finish capturing, press 'ESC' key and calibration starts.\n";
+const char* keys  =
+        "{w        |       | Number of squares in X direction }"
+        "{h        |       | Number of squares in Y direction }"
+        "{sl       |       | Square side length (in meters) }"
+        "{ml       |       | Marker side length (in meters) }"
+        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{cd       |       | Input file with custom dictionary }"
+        "{@outfile |cam.yml| Output file with calibrated camera parameters }"
+        "{v        |       | Input from video file, if ommited, input comes from camera }"
+        "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
+        "{dp       |       | File of marker detector parameters }"
+        "{rs       | false | Apply refind strategy }"
+        "{zt       | false | Assume zero tangential distortion }"
+        "{a        |       | Fix aspect ratio (fx/fy) to this value }"
+        "{pc       | false | Fix the principal point at the center }"
+        "{sc       | false | Show detected chessboard corners after calibration }";
+}
+
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 7) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int squaresX = parser.get<int>("w");
+    int squaresY = parser.get<int>("h");
+    float squareLength = parser.get<float>("sl");
+    float markerLength = parser.get<float>("ml");
+    string outputFile = parser.get<string>(0);
+
+    bool showChessboardCorners = parser.get<bool>("sc");
+
+    int calibrationFlags = 0;
+    float aspectRatio = 1;
+    if(parser.has("a")) {
+        calibrationFlags |= CALIB_FIX_ASPECT_RATIO;
+        aspectRatio = parser.get<float>("a");
+    }
+    if(parser.get<bool>("zt")) calibrationFlags |= CALIB_ZERO_TANGENT_DIST;
+    if(parser.get<bool>("pc")) calibrationFlags |= CALIB_FIX_PRINCIPAL_POINT;
+
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+
+    bool refindStrategy = parser.get<bool>("rs");
+    int camId = parser.get<int>("ci");
+    String video;
+
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(!video.empty()) {
+        inputVideo.open(video);
+        waitTime = 0;
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    aruco::CharucoParameters charucoParams;
+    if(refindStrategy) {
+        charucoParams.tryRefineMarkers = true;
+    }
+
+    //! [CalibrationWithCharucoBoard1]
+    // Create charuco board object and CharucoDetector
+    aruco::CharucoBoard board(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
+    aruco::CharucoDetector detector(board, charucoParams, detectorParams);
+
+    // Collect data from each frame
+    vector<Mat> allCharucoCorners, allCharucoIds;
+
+    vector<vector<Point2f>> allImagePoints;
+    vector<vector<Point3f>> allObjectPoints;
+
+    vector<Mat> allImages;
+    Size imageSize;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        vector<int> markerIds;
+        vector<vector<Point2f>> markerCorners;
+        Mat currentCharucoCorners, currentCharucoIds;
+        vector<Point3f> currentObjectPoints;
+        vector<Point2f> currentImagePoints;
+
+        // Detect ChArUco board
+        detector.detectBoard(image, currentCharucoCorners, currentCharucoIds);
+        //! [CalibrationWithCharucoBoard1]
+
+        // Draw results
+        image.copyTo(imageCopy);
+        if(!markerIds.empty()) {
+            aruco::drawDetectedMarkers(imageCopy, markerCorners);
+        }
+
+        if(currentCharucoCorners.total() > 3) {
+            aruco::drawDetectedCornersCharuco(imageCopy, currentCharucoCorners, currentCharucoIds);
+        }
+
+        putText(imageCopy, "Press 'c' to add current frame. 'ESC' to finish and calibrate",
+                Point(10, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 0), 2);
+
+        imshow("out", imageCopy);
+
+        // Wait for key pressed
+        char key = (char)waitKey(waitTime);
+
+        if(key == 27) {
+            break;
+        }
+
+        //! [CalibrationWithCharucoBoard2]
+        if(key == 'c' && currentCharucoCorners.total() > 3) {
+            // Match image points
+            board.matchImagePoints(currentCharucoCorners, currentCharucoIds, currentObjectPoints, currentImagePoints);
+
+            if(currentImagePoints.empty() || currentObjectPoints.empty()) {
+                cout << "Point matching failed, try again." << endl;
+                continue;
+            }
+
+            cout << "Frame captured" << endl;
+
+            allCharucoCorners.push_back(currentCharucoCorners);
+            allCharucoIds.push_back(currentCharucoIds);
+            allImagePoints.push_back(currentImagePoints);
+            allObjectPoints.push_back(currentObjectPoints);
+            allImages.push_back(image);
+
+            imageSize = image.size();
+        }
+    }
+    //! [CalibrationWithCharucoBoard2]
+
+    if(allCharucoCorners.size() < 4) {
+        cerr << "Not enough corners for calibration" << endl;
+        return 0;
+    }
+
+    //! [CalibrationWithCharucoBoard3]
+    Mat cameraMatrix, distCoeffs;
+
+    if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
+        cameraMatrix = Mat::eye(3, 3, CV_64F);
+        cameraMatrix.at<double>(0, 0) = aspectRatio;
+    }
+
+    // Calibrate camera using ChArUco
+    double repError = calibrateCamera(allObjectPoints, allImagePoints, imageSize, cameraMatrix, distCoeffs,
+                                      noArray(), noArray(), noArray(), noArray(), noArray(), calibrationFlags);
+    //! [CalibrationWithCharucoBoard3]
+
+    bool saveOk =  saveCameraParams(outputFile, imageSize, aspectRatio, calibrationFlags,
+                                    cameraMatrix, distCoeffs, repError);
+
+    if(!saveOk) {
+        cerr << "Cannot save output file" << endl;
+        return 0;
+    }
+
+    cout << "Rep Error: " << repError << endl;
+    cout << "Calibration saved to " << outputFile << endl;
+
+    // Show interpolated charuco corners for debugging
+    if(showChessboardCorners) {
+        for(size_t frame = 0; frame < allImages.size(); frame++) {
+            Mat imageCopy = allImages[frame].clone();
+
+            if(allCharucoCorners[frame].total() > 0) {
+                aruco::drawDetectedCornersCharuco(imageCopy, allCharucoCorners[frame], allCharucoIds[frame]);
+            }
+
+            imshow("out", imageCopy);
+            char key = (char)waitKey(0);
+            if(key == 27) {
+                break;
+            }
+        }
+    }
+    return 0;
+}
@@ -23,7 +23,6 @@ const char* keys  =
        "{si       | false | show generated image }";
 }

-
 int main(int argc, char *argv[]) {
    CommandLineParser parser(argc, argv, keys);
    parser.about(about);
@@ -57,25 +56,7 @@ int main(int argc, char *argv[]) {
    imageSize.height =
        markersY * (markerLength + markerSeparation) - markerSeparation + 2 * margins;

-    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
-    if (parser.has("d")) {
-        int dictionaryId = parser.get<int>("d");
-        dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
-    }
-    else if (parser.has("cd")) {
-        FileStorage fs(parser.get<std::string>("cd"), FileStorage::READ);
-        bool readOk = dictionary.readDictionary(fs.root());
-        if(!readOk)
-        {
-            std::cerr << "Invalid dictionary file" << std::endl;
-            return 0;
-        }
-    }
-    else {
-        std::cerr << "Dictionary not specified" << std::endl;
-        return 0;
-    }
-
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
    aruco::GridBoard board(Size(markersX, markersY), float(markerLength), float(markerSeparation), dictionary);

    // show created board
@@ -90,6 +71,5 @@ int main(int argc, char *argv[]) {
    }

    imwrite(out, boardImage);
-
    return 0;
 }
@@ -0,0 +1,77 @@
+#include <opencv2/highgui.hpp>
+#include <opencv2/objdetect/charuco_detector.hpp>
+#include <iostream>
+#include "aruco_samples_utility.hpp"
+
+using namespace cv;
+
+namespace {
+const char* about = "Create a ChArUco board image";
+//! [charuco_detect_board_keys]
+const char* keys  =
+        "{@outfile |res.png| Output image }"
+        "{w        |  5    | Number of squares in X direction }"
+        "{h        |  7    | Number of squares in Y direction }"
+        "{sl       |  100  | Square side length (in pixels) }"
+        "{ml       |  60   | Marker side length (in pixels) }"
+        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{cd       |       | Input file with custom dictionary }"
+        "{m        |       | Margins size (in pixels). Default is (squareLength-markerLength) }"
+        "{bb       | 1     | Number of bits in marker borders }"
+        "{si       | false | show generated image }";
+}
+//! [charuco_detect_board_keys]
+
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+    if (argc == 1) {
+        parser.printMessage();
+    }
+
+    int squaresX = parser.get<int>("w");
+    int squaresY = parser.get<int>("h");
+    int squareLength = parser.get<int>("sl");
+    int markerLength = parser.get<int>("ml");
+    int margins = squareLength - markerLength;
+    if(parser.has("m")) {
+        margins = parser.get<int>("m");
+    }
+
+    int borderBits = parser.get<int>("bb");
+    bool showImage = parser.get<bool>("si");
+
+    std::string pathOutImg = parser.get<std::string>(0);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    //! [create_charucoBoard]
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+    cv::aruco::CharucoBoard board(Size(squaresX, squaresY), (float)squareLength, (float)markerLength, dictionary);
+    //! [create_charucoBoard]
+
+    // show created board
+    //! [generate_charucoBoard]
+    Mat boardImage;
+    Size imageSize;
+    imageSize.width = squaresX * squareLength + 2 * margins;
+    imageSize.height = squaresY * squareLength + 2 * margins;
+    board.generateImage(imageSize, boardImage, margins, borderBits);
+    //! [generate_charucoBoard]
+
+    if(showImage) {
+        imshow("board", boardImage);
+        waitKey(0);
+    }
+
+    if (pathOutImg != "")
+        imwrite(pathOutImg, boardImage);
+    return 0;
+}
@@ -0,0 +1,72 @@
+#include <opencv2/highgui.hpp>
+#include <opencv2/objdetect/charuco_detector.hpp>
+#include <vector>
+#include <iostream>
+#include "aruco_samples_utility.hpp"
+
+using namespace std;
+using namespace cv;
+
+namespace {
+const char* about = "Create a ChArUco marker image";
+const char* keys  =
+        "{@outfile |   res.png | Output image }"
+        "{sl       |   100     | Square side length (in pixels) }"
+        "{ml       |   60      | Marker side length (in pixels) }"
+        "{cd       |           | Input file with custom dictionary }"
+        "{d        |   10      | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{ids      |0, 1, 2, 3 | Four ids for the ChArUco marker: id1,id2,id3,id4 }"
+        "{m        |   0       | Margins size (in pixels) }"
+        "{bb       |   1       | Number of bits in marker borders }"
+        "{si       |   false   | show generated image }";
+}
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    int squareLength = parser.get<int>("sl");
+    int markerLength = parser.get<int>("ml");
+    string idsString = parser.get<string>("ids");
+    int margins = parser.get<int>("m");
+    int borderBits = parser.get<int>("bb");
+    bool showImage = parser.get<bool>("si");
+    string out = parser.get<string>(0);
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    istringstream ss(idsString);
+    vector<string> splittedIds;
+    string token;
+    while(getline(ss, token, ','))
+        splittedIds.push_back(token);
+    if(splittedIds.size() < 4) {
+        throw std::runtime_error("Incorrect ids format\n");
+    }
+    Vec4i ids;
+    for(int i = 0; i < 4; i++)
+        ids[i] = atoi(splittedIds[i].c_str());
+
+    //! [generate_diamond]
+    vector<int> diamondIds = {ids[0], ids[1], ids[2], ids[3]};
+    aruco::CharucoBoard charucoBoard(Size(3, 3), (float)squareLength, (float)markerLength, dictionary, diamondIds);
+    Mat markerImg;
+    charucoBoard.generateImage(Size(3*squareLength + 2*margins, 3*squareLength + 2*margins), markerImg, margins, borderBits);
+    //! [generate_diamond]
+
+    if(showImage) {
+        imshow("board", markerImg);
+        waitKey(0);
+    }
+
+    if (out != "")
+        imwrite(out, markerImg);
+    return 0;
+}
@@ -10,13 +10,13 @@ const char* about = "Create an ArUco marker image";

 //! [aruco_create_markers_keys]
 const char* keys  =
-        "{@outfile |<none> | Output image }"
-        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "{@outfile |res.png| Output image }"
+        "{d        | 0     | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
        "{cd       |       | Input file with custom dictionary }"
-        "{id       |       | Marker id in the dictionary }"
+        "{id       | 0     | Marker id in the dictionary }"
        "{ms       | 200   | Marker size in pixels }"
        "{bb       | 1     | Number of bits in marker borders }"
        "{si       | false | show generated image }";
@@ -28,11 +28,6 @@ int main(int argc, char *argv[]) {
    CommandLineParser parser(argc, argv, keys);
    parser.about(about);

-    if(argc < 4) {
-        parser.printMessage();
-        return 0;
-    }
-
    int markerId = parser.get<int>("id");
    int borderBits = parser.get<int>("bb");
    int markerSize = parser.get<int>("ms");
@@ -45,23 +40,7 @@ int main(int argc, char *argv[]) {
        return 0;
    }

-    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
-    if (parser.has("d")) {
-        int dictionaryId = parser.get<int>("d");
-        dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
-    }
-    else if (parser.has("cd")) {
-        FileStorage fs(parser.get<std::string>("cd"), FileStorage::READ);
-        bool readOk = dictionary.readDictionary(fs.root());
-        if(!readOk) {
-            std::cerr << "Invalid dictionary file" << std::endl;
-            return 0;
-        }
-    }
-    else {
-        std::cerr << "Dictionary not specified" << std::endl;
-        return 0;
-    }
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);

    Mat markerImg;
    aruco::generateImageMarker(dictionary, markerId, markerSize, markerImg, borderBits);
@@ -30,46 +30,6 @@ const char* keys  =
 }
 //! [aruco_detect_board_keys]

-static void readDetectorParamsFromCommandLine(CommandLineParser &parser, aruco::DetectorParameters& detectorParams) {
-    if(parser.has("dp")) {
-        FileStorage fs(parser.get<string>("dp"), FileStorage::READ);
-        bool readOk = detectorParams.readDetectorParameters(fs.root());
-        if(!readOk) {
-            cerr << "Invalid detector parameters file" << endl;
-            throw -1;
-        }
-    }
-}
-
-static void readCameraParamsFromCommandLine(CommandLineParser &parser, Mat& camMatrix, Mat& distCoeffs) {
-    if(parser.has("c")) {
-        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
-        if(!readOk) {
-            cerr << "Invalid camera file" << endl;
-            throw -1;
-        }
-    }
-}
-
-static void readDictionatyFromCommandLine(CommandLineParser &parser, aruco::Dictionary& dictionary) {
-    if (parser.has("d")) {
-        int dictionaryId = parser.get<int>("d");
-        dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
-    }
-    else if (parser.has("cd")) {
-        FileStorage fs(parser.get<string>("cd"), FileStorage::READ);
-        bool readOk = dictionary.readDictionary(fs.root());
-        if(!readOk) {
-            cerr << "Invalid dictionary file" << endl;
-            throw -1;
-        }
-    }
-    else {
-        cerr << "Dictionary not specified" << endl;
-        throw -1;
-    }
-}
-
 int main(int argc, char *argv[]) {
    CommandLineParser parser(argc, argv, keys);
    parser.about(about);
@@ -91,10 +51,8 @@ int main(int argc, char *argv[]) {

    Mat camMatrix, distCoeffs;
    readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
-
-    aruco::DetectorParameters detectorParams;
-    detectorParams.cornerRefinementMethod = aruco::CORNER_REFINE_SUBPIX; // do corner refinement in markers
-    readDetectorParamsFromCommandLine(parser, detectorParams);
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);

    String video;
    if(parser.has("v")) {
@@ -106,9 +64,6 @@ int main(int argc, char *argv[]) {
        return 0;
    }

-    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
-    readDictionatyFromCommandLine(parser, dictionary);
-
    aruco::ArucoDetector detector(dictionary, detectorParams);
    VideoCapture inputVideo;
    int waitTime;
@@ -181,9 +136,8 @@ int main(int argc, char *argv[]) {

        // Draw results
        image.copyTo(imageCopy);
-        if(!ids.empty()) {
+        if(!ids.empty())
            aruco::drawDetectedMarkers(imageCopy, corners, ids);
-        }

        if(showRejected && !rejected.empty())
            aruco::drawDetectedMarkers(imageCopy, rejected, noArray(), Scalar(100, 0, 255));
@@ -0,0 +1,144 @@
+#include <opencv2/highgui.hpp>
+//! [charucohdr]
+#include <opencv2/objdetect/charuco_detector.hpp>
+//! [charucohdr]
+#include <vector>
+#include <iostream>
+#include "aruco_samples_utility.hpp"
+
+using namespace std;
+using namespace cv;
+
+namespace {
+const char* about = "Pose estimation using a ChArUco board";
+const char* keys  =
+        "{w        |       | Number of squares in X direction }"
+        "{h        |       | Number of squares in Y direction }"
+        "{sl       |       | Square side length (in meters) }"
+        "{ml       |       | Marker side length (in meters) }"
+        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{cd       |       | Input file with custom dictionary }"
+        "{c        |       | Output file with calibrated camera parameters }"
+        "{v        |       | Input from video or image file, if ommited, input comes from camera }"
+        "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
+        "{dp       |       | File of marker detector parameters }"
+        "{rs       |       | Apply refind strategy }";
+}
+
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 6) {
+        parser.printMessage();
+        return 0;
+    }
+
+    //! [charuco_detect_board_full_sample]
+    int squaresX = parser.get<int>("w");
+    int squaresY = parser.get<int>("h");
+    float squareLength = parser.get<float>("sl");
+    float markerLength = parser.get<float>("ml");
+    bool refine = parser.has("rs");
+    int camId = parser.get<int>("ci");
+
+    string video;
+    if(parser.has("v")) {
+        video = parser.get<string>("v");
+    }
+
+    Mat camMatrix, distCoeffs;
+    readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture inputVideo;
+    int waitTime = 0;
+    if(!video.empty()) {
+        inputVideo.open(video);
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    float axisLength = 0.5f * ((float)min(squaresX, squaresY) * (squareLength));
+
+    // create charuco board object
+    aruco::CharucoBoard charucoBoard(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
+
+    // create charuco detector
+    aruco::CharucoParameters charucoParams;
+    charucoParams.tryRefineMarkers = refine; // if tryRefineMarkers, refineDetectedMarkers() will be used in detectBoard()
+    charucoParams.cameraMatrix = camMatrix; // cameraMatrix can be used in detectBoard()
+    charucoParams.distCoeffs = distCoeffs; // distCoeffs can be used in detectBoard()
+    aruco::CharucoDetector charucoDetector(charucoBoard, charucoParams, detectorParams);
+
+    double totalTime = 0;
+    int totalIterations = 0;
+
+    while(inputVideo.grab()) {
+        //! [inputImg]
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        //! [inputImg]
+
+        double tick = (double)getTickCount();
+
+        vector<int> markerIds, charucoIds;
+        vector<vector<Point2f> > markerCorners;
+        vector<Point2f> charucoCorners;
+        Vec3d rvec, tvec;
+
+        //! [interpolateCornersCharuco]
+        // detect markers and charuco corners
+        charucoDetector.detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds);
+        //! [interpolateCornersCharuco]
+
+        //! [poseCharuco]
+        // estimate charuco board pose
+        bool validPose = false;
+        if(camMatrix.total() != 0 && distCoeffs.total() != 0 && charucoIds.size() >= 4) {
+            Mat objPoints, imgPoints;
+            charucoBoard.matchImagePoints(charucoCorners, charucoIds, objPoints, imgPoints);
+            validPose = solvePnP(objPoints, imgPoints, camMatrix, distCoeffs, rvec, tvec);
+        }
+        //! [poseCharuco]
+
+        double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
+        totalTime += currentTime;
+        totalIterations++;
+        if(totalIterations % 30 == 0) {
+            cout << "Detection Time = " << currentTime * 1000 << " ms "
+                 << "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
+        }
+
+        // draw results
+        image.copyTo(imageCopy);
+        if(markerIds.size() > 0) {
+            aruco::drawDetectedMarkers(imageCopy, markerCorners);
+        }
+
+        if(charucoIds.size() > 0) {
+            //! [drawDetectedCornersCharuco]
+            aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
+            //! [drawDetectedCornersCharuco]
+        }
+
+        if(validPose)
+            cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvec, tvec, axisLength);
+
+        imshow("out", imageCopy);
+        if(waitKey(waitTime) == 27) break;
+    }
+    //! [charuco_detect_board_full_sample]
+    return 0;
+}
@@ -0,0 +1,187 @@
+#include <opencv2/highgui.hpp>
+#include <vector>
+#include <iostream>
+#include <opencv2/objdetect/charuco_detector.hpp>
+#include "aruco_samples_utility.hpp"
+
+using namespace std;
+using namespace cv;
+
+
+namespace {
+const char* about = "Detect ChArUco markers";
+const char* keys  =
+        "{sl       | 100   | Square side length (in meters) }"
+        "{ml       | 60    | Marker side length (in meters) }"
+        "{d        | 10    | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
+        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
+        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16}"
+        "{cd       |       | Input file with custom dictionary }"
+        "{c        |       | Output file with calibrated camera parameters }"
+        "{as       |       | Automatic scale. The provided number is multiplied by the last"
+        "diamond id becoming an indicator of the square length. In this case, the -sl and "
+        "-ml are only used to know the relative length relation between squares and markers }"
+        "{v        |       | Input from video file, if ommited, input comes from camera }"
+        "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
+        "{dp       |       | File of marker detector parameters }"
+        "{refine   |       | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"
+        "CORNER_REFINE_CONTOUR=2, CORNER_REFINE_APRILTAG=3}";
+
+const string refineMethods[4] = {
+    "None",
+    "Subpixel",
+    "Contour",
+    "AprilTag"
+};
+
+}
+
+int main(int argc, char *argv[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    float squareLength = parser.get<float>("sl");
+    float markerLength = parser.get<float>("ml");
+    bool estimatePose = parser.has("c");
+    bool autoScale = parser.has("as");
+    float autoScaleFactor = autoScale ? parser.get<float>("as") : 1.f;
+
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
+    Mat camMatrix, distCoeffs;
+    readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
+
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
+    if (parser.has("refine")) {
+        // override cornerRefinementMethod read from config file
+        int user_method = parser.get<aruco::CornerRefineMethod>("refine");
+        if (user_method < 0 || user_method >= 4)
+        {
+            std::cout << "Corner refinement method should be in range 0..3" << std::endl;
+            return 0;
+        }
+        detectorParams.cornerRefinementMethod = user_method;
+    }
+    std::cout << "Corner refinement method: " << refineMethods[detectorParams.cornerRefinementMethod] << std::endl;
+
+    int camId = parser.get<int>("ci");
+    String video;
+
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(!video.empty()) {
+        inputVideo.open(video);
+        waitTime = 0;
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    double totalTime = 0;
+    int totalIterations = 0;
+
+    aruco::CharucoBoard charucoBoard(Size(3, 3), squareLength, markerLength, dictionary);
+    aruco::CharucoDetector detector(charucoBoard, aruco::CharucoParameters(), detectorParams);
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        //! [detect_diamonds]
+        vector<int> markerIds;
+        vector<Vec4i> diamondIds;
+        vector<vector<Point2f> > markerCorners, diamondCorners;
+        vector<Vec3d> rvecs, tvecs;
+
+        detector.detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds);
+        //! [detect_diamonds]
+
+        //! [diamond_pose_estimation]
+        // estimate diamond pose
+        size_t N = diamondIds.size();
+        if(estimatePose && N > 0) {
+            cv::Mat objPoints(4, 1, CV_32FC3);
+            rvecs.resize(N);
+            tvecs.resize(N);
+            if(!autoScale) {
+                // set coordinate system
+                objPoints.ptr<Vec3f>(0)[0] = Vec3f(-squareLength/2.f, squareLength/2.f, 0);
+                objPoints.ptr<Vec3f>(0)[1] = Vec3f(squareLength/2.f, squareLength/2.f, 0);
+                objPoints.ptr<Vec3f>(0)[2] = Vec3f(squareLength/2.f, -squareLength/2.f, 0);
+                objPoints.ptr<Vec3f>(0)[3] = Vec3f(-squareLength/2.f, -squareLength/2.f, 0);
+                // Calculate pose for each marker
+                for (size_t i = 0ull; i < N; i++)
+                    solvePnP(objPoints, diamondCorners.at(i), camMatrix, distCoeffs, rvecs.at(i), tvecs.at(i));
+                //! [diamond_pose_estimation]
+                /* //! [diamond_pose_estimation_as_charuco]
+                for (size_t i = 0ull; i < N; i++) { // estimate diamond pose as Charuco board
+                    Mat objPoints_b, imgPoints;
+                    // The coordinate system of the diamond is placed in the board plane centered in the bottom left corner
+                    vector<int> charucoIds = {0, 1, 3, 2}; // if CCW order, Z axis pointing in the plane
+                    // vector<int> charucoIds = {0, 2, 3, 1}; // if CW order, Z axis pointing out the plane
+                    charucoBoard.matchImagePoints(diamondCorners[i], charucoIds, objPoints_b, imgPoints);
+                    solvePnP(objPoints_b, imgPoints, camMatrix, distCoeffs, rvecs[i], tvecs[i]);
+                }
+                //! [diamond_pose_estimation_as_charuco] */
+            }
+            else {
+                // if autoscale, extract square size from last diamond id
+                for(size_t i = 0; i < N; i++) {
+                    float sqLenScale = autoScaleFactor * float(diamondIds[i].val[3]);
+                    vector<vector<Point2f> > currentCorners;
+                    vector<Vec3d> currentRvec, currentTvec;
+                    currentCorners.push_back(diamondCorners[i]);
+                    // set coordinate system
+                    objPoints.ptr<Vec3f>(0)[0] = Vec3f(-sqLenScale/2.f, sqLenScale/2.f, 0);
+                    objPoints.ptr<Vec3f>(0)[1] = Vec3f(sqLenScale/2.f, sqLenScale/2.f, 0);
+                    objPoints.ptr<Vec3f>(0)[2] = Vec3f(sqLenScale/2.f, -sqLenScale/2.f, 0);
+                    objPoints.ptr<Vec3f>(0)[3] = Vec3f(-sqLenScale/2.f, -sqLenScale/2.f, 0);
+                    solvePnP(objPoints, diamondCorners.at(i), camMatrix, distCoeffs, rvecs.at(i), tvecs.at(i));
+                }
+            }
+        }
+
+
+        double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
+        totalTime += currentTime;
+        totalIterations++;
+        if(totalIterations % 30 == 0) {
+            cout << "Detection Time = " << currentTime * 1000 << " ms "
+                 << "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
+        }
+
+
+        // draw results
+        image.copyTo(imageCopy);
+        if(markerIds.size() > 0)
+            aruco::drawDetectedMarkers(imageCopy, markerCorners);
+
+        //! [draw_diamonds]
+        if(diamondIds.size() > 0) {
+            aruco::drawDetectedDiamonds(imageCopy, diamondCorners, diamondIds);
+        //! [draw_diamonds]
+
+            //! [draw_diamond_pose_estimation]
+            if(estimatePose) {
+                for(size_t i = 0u; i < diamondIds.size(); i++)
+                    cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvecs[i], tvecs[i], squareLength*1.1f);
+            }
+            //! [draw_diamond_pose_estimation]
+        }
+        imshow("out", imageCopy);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+    }
+    return 0;
+}
@@ -11,7 +11,7 @@ const char* about = "Basic marker detection";

 //! [aruco_detect_markers_keys]
 const char* keys  =
-        "{d        |       | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
+        "{d        | 0     | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
        "DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
        "DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
        "DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16,"
@@ -25,37 +25,41 @@ const char* keys  =
        "{r        |       | show rejected candidates too }"
        "{refine   |       | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"
        "CORNER_REFINE_CONTOUR=2, CORNER_REFINE_APRILTAG=3}";
-}
+
 //! [aruco_detect_markers_keys]

+const string refineMethods[4] = {
+    "None",
+    "Subpixel",
+    "Contour",
+    "AprilTag"
+};
+
+}
+
 int main(int argc, char *argv[]) {
    CommandLineParser parser(argc, argv, keys);
    parser.about(about);

-    if(argc < 2) {
-        parser.printMessage();
-        return 0;
-    }
-
    bool showRejected = parser.has("r");
    bool estimatePose = parser.has("c");
    float markerLength = parser.get<float>("l");

-    cv::aruco::DetectorParameters detectorParams;
-    if(parser.has("dp")) {
-        cv::FileStorage fs(parser.get<string>("dp"), FileStorage::READ);
-        bool readOk = detectorParams.readDetectorParameters(fs.root());
-        if(!readOk) {
-            cerr << "Invalid detector parameters file" << endl;
-            return 0;
-        }
-    }
+    aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
+    aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);

    if (parser.has("refine")) {
        // override cornerRefinementMethod read from config file
-        detectorParams.cornerRefinementMethod = parser.get<aruco::CornerRefineMethod>("refine");
+        int user_method = parser.get<aruco::CornerRefineMethod>("refine");
+        if (user_method < 0 || user_method >= 4)
+        {
+            std::cout << "Corner refinement method should be in range 0..3" << std::endl;
+            return 0;
+        }
+        detectorParams.cornerRefinementMethod = user_method;
    }
-    std::cout << "Corner refinement method (0: None, 1: Subpixel, 2:contour, 3: AprilTag 2): " << (int)detectorParams.cornerRefinementMethod << std::endl;
+
+    std::cout << "Corner refinement method: " << refineMethods[detectorParams.cornerRefinementMethod] << std::endl;

    int camId = parser.get<int>("ci");

@@ -69,33 +73,11 @@ int main(int argc, char *argv[]) {
        return 0;
    }

-    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
-    if (parser.has("d")) {
-        int dictionaryId = parser.get<int>("d");
-        dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
-    }
-    else if (parser.has("cd")) {
-        cv::FileStorage fs(parser.get<std::string>("cd"), FileStorage::READ);
-        bool readOk = dictionary.readDictionary(fs.root());
-        if(!readOk) {
-            std::cerr << "Invalid dictionary file" << std::endl;
-            return 0;
-        }
-    }
-    else {
-        std::cerr << "Dictionary not specified" << std::endl;
-        return 0;
-    }
-
    //! [aruco_pose_estimation1]
-    cv::Mat camMatrix, distCoeffs;
+    Mat camMatrix, distCoeffs;
    if(estimatePose) {
        // You can read camera parameters from tutorial_camera_params.yml
-        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
-        if(!readOk) {
-            cerr << "Invalid camera file" << endl;
-            return 0;
-        }
+        readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
    }
    //! [aruco_pose_estimation1]
    //! [aruco_detect_markers]
@@ -0,0 +1,30 @@
+%YAML:1.0
+adaptiveThreshWinSizeMin: 3
+adaptiveThreshWinSizeMax: 23
+adaptiveThreshWinSizeStep: 10
+adaptiveThreshWinSize: 21
+adaptiveThreshConstant: 7
+minMarkerPerimeterRate: 0.03
+maxMarkerPerimeterRate: 4.0
+polygonalApproxAccuracyRate: 0.05
+minCornerDistanceRate: 0.05
+minDistanceToBorder: 3
+minMarkerDistance: 10.0
+minMarkerDistanceRate: 0.05
+cornerRefinementMethod: 0
+cornerRefinementWinSize: 5
+cornerRefinementMaxIterations: 30
+cornerRefinementMinAccuracy: 0.1
+markerBorderBits: 1
+perspectiveRemovePixelPerCell: 8
+perspectiveRemoveIgnoredMarginPerCell: 0.13
+maxErroneousBitsInBorderRate: 0.04
+minOtsuStdDev: 5.0
+errorCorrectionRate: 0.6
+
+# new aruco 3 functionality
+useAruco3Detection: 0
+minSideLengthCanonicalImg: 32 # 16, 32, 64 --> tau_c from the paper
+minMarkerLengthRatioOriginalImg: 0.02 # range [0,0.2] --> tau_i from the paper
+cameraMotionSpeed: 0.1 # range [0,1) --> tau_s from the paper
+useGlobalThreshold: 0
@@ -0,0 +1,21 @@
+%YAML:1.0
+---
+calibration_time: "Wed 08 Dec 2021 05:13:09 PM MSK"
+image_width: 640
+image_height: 480
+flags: 0
+camera_matrix: !!opencv-matrix
+   rows: 3
+   cols: 3
+   dt: d
+   data: [ 4.5251072219637672e+02, 0., 3.1770297317353277e+02, 0.,
+       4.5676707935146891e+02, 2.7775155919135995e+02, 0., 0., 1. ]
+distortion_coefficients: !!opencv-matrix
+   rows: 1
+   cols: 5
+   dt: d
+   data: [ 1.2136925618707872e-01, -1.0854664722560681e+00,
+       1.1786843796668460e-04, -4.6240686046485508e-04,
+       2.9542589406810080e+00 ]
+avg_reprojection_error: 1.8234905535936044e-01
+info: "The camera calibration parameters were obtained by img_00.jpg-img_03.jpg from aruco/tutorials/aruco_calibration/images"