Added aruco module

modules/aruco/CMakeLists.txt

+set(the_description "ArUco Marker Detection")
+ocv_define_module(aruco opencv_core opencv_imgproc opencv_calib3d WRAP python)

modules/aruco/README.md

+ArUco Marker Detection
+======================

modules/aruco/include/opencv2/aruco/dictionary.hpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef __OPENCV_DICTIONARY_HPP__
+#define __OPENCV_DICTIONARY_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup aruco
+//! @{
+
+
+/**
+ * @brief Dictionary/Set of markers. It contains the inner codification
+ *
+ */
+class CV_EXPORTS Dictionary {
+
+    public:
+    Mat bytesList;         // marker code information
+    int markerSize;        // number of bits per dimension
+    int maxCorrectionBits; // maximum number of bits that can be corrected
+
+
+    /**
+      */
+    Dictionary(const unsigned char *bytes = 0, int _markerSize = 0, int dictsize = 0,
+               int _maxcorr = 0);
+
+
+
+    /**
+     * @brief Given a matrix of bits. Returns whether if marker is identified or not.
+     * It returns by reference the correct id (if any) and the correct rotation
+     */
+    bool identify(const Mat &onlyBits, int &idx, int &rotation, double maxCorrectionRate) const;
+
+    /**
+      * @brief Returns the distance of the input bits to the specific id. If allRotations is true,
+      * the four posible bits rotation are considered
+      */
+    int getDistanceToId(InputArray bits, int id, bool allRotations = true) const;
+
+
+    /**
+     * @brief Draw a canonical marker image
+     */
+    void drawMarker(int id, int sidePixels, OutputArray _img, int borderBits = 1) const;
+
+
+    /**
+      * @brief Transform matrix of bits to list of bytes in the 4 rotations
+      */
+    static Mat getByteListFromBits(const Mat &bits);
+
+
+    /**
+      * @brief Transform list of bytes to matrix of bits
+      */
+    static Mat getBitsFromByteList(const Mat &byteList, int markerSize);
+};
+
+
+
+
+/**
+ * @brief Predefined markers dictionaries/sets
+ * Each dictionary indicates the number of bits and the number of markers contained
+ * - DICT_ARUCO: standard ArUco Library Markers. 1024 markers, 5x5 bits, 0 minimum distance
+ */
+enum PREDEFINED_DICTIONARY_NAME {
+    DICT_4X4_50 = 0,
+    DICT_4X4_100,
+    DICT_4X4_250,
+    DICT_4X4_1000,
+    DICT_5X5_50,
+    DICT_5X5_100,
+    DICT_5X5_250,
+    DICT_5X5_1000,
+    DICT_6X6_50,
+    DICT_6X6_100,
+    DICT_6X6_250,
+    DICT_6X6_1000,
+    DICT_7X7_50,
+    DICT_7X7_100,
+    DICT_7X7_250,
+    DICT_7X7_1000,
+    DICT_ARUCO_ORIGINAL
+};
+
+
+/**
+  * @brief Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME
+  */
+CV_EXPORTS const Dictionary &getPredefinedDictionary(PREDEFINED_DICTIONARY_NAME name);
+
+
+/**
+  * @brief Generates a new customizable marker dictionary
+  *
+  * @param nMarkers number of markers in the dictionary
+  * @param markerSize number of bits per dimension of each markers
+  * @param baseDictionary Include the markers in this dictionary at the beginning (optional)
+  *
+  * This function creates a new dictionary composed by nMarkers markers and each markers composed
+  * by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly
+  * included and the rest are generated based on them. If the size of baseDictionary is higher
+  * than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.
+  */
+CV_EXPORTS Dictionary generateCustomDictionary(int nMarkers, int markerSize,
+                                               const Dictionary &baseDictionary = Dictionary());
+
+
+
+//! @}
+}
+}
+
+#endif

modules/aruco/samples/create_board.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Create an ArUco grid board image" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-o <image> # Output image" << endl;
+    cout << "-w <nmarkers> # Number of markers in X direction" << endl;
+    cout << "-h <nmarkers> # Number of markers in Y direction" << endl;
+    cout << "-l <markerLength> # Marker side lenght (in pixels)" << endl;
+    cout << "-s <markerSeparation> # Separation between two consecutive"
+         << "markers in the grid (in pixels)" << endl;
+    cout << "-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" << endl;
+    cout << "[-m <marginSize>] # Margins size (in pixels)"
+         << "Default is marker separation" << endl;
+    cout << "[-bb <int>] # Number of bits in marker borders. Default is 1" << endl;
+    cout << "[-si] # show generated image" << endl;
+}
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-w", argc, argv) || !isParam("-h", argc, argv) || !isParam("-l", argc, argv) ||
+       !isParam("-s", argc, argv) || !isParam("-d", argc, argv) || !isParam("-o", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int markersX = atoi(getParam("-w", argc, argv).c_str());
+    int markersY = atoi(getParam("-h", argc, argv).c_str());
+    int markerLength = atoi(getParam("-l", argc, argv).c_str());
+    int markerSeparation = atoi(getParam("-s", argc, argv).c_str());
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    int margins = markerSeparation;
+    if(isParam("-m", argc, argv)) {
+        margins = atoi(getParam("-m", argc, argv).c_str());
+    }
+
+    int borderBits = 1;
+    if(isParam("-bb", argc, argv)) {
+        borderBits = atoi(getParam("-bb", argc, argv).c_str());
+    }
+
+    bool showImage = false;
+    if(isParam("-si", argc, argv)) showImage = true;
+
+    Size imageSize;
+    imageSize.width = markersX * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
+    imageSize.height =
+        markersY * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
+
+    aruco::GridBoard board = aruco::GridBoard::create(markersX, markersY, float(markerLength),
+                                                      float(markerSeparation), dictionary);
+
+    // show created board
+    Mat boardImage;
+    board.draw(imageSize, boardImage, margins, borderBits);
+
+    if(showImage) {
+        imshow("board", boardImage);
+        waitKey(0);
+    }
+
+    imwrite(getParam("-o", argc, argv), boardImage);
+
+    return 0;
+}

modules/aruco/samples/create_board_charuco.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco/charuco.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Create a ChArUco board image" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-o <image> # Output image" << endl;
+    cout << "-w <nsquares> # Number of squares in X direction" << endl;
+    cout << "-h <nsquares> # Number of squares in Y direction" << endl;
+    cout << "-sl <squareLength> # Square side lenght (in pixels)" << endl;
+    cout << "-ml <markerLength> # Marker side lenght (in pixels)" << endl;
+    cout << "-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" << endl;
+    cout << "[-m <marginSize>] # Margins size (in pixels)"
+         << "Default is (squareLength-markerLength)" << endl;
+    cout << "[-bb <int>] # Number of bits in marker borders. Default is 1" << endl;
+    cout << "[-si] # show generated image" << endl;
+}
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-w", argc, argv) || !isParam("-h", argc, argv) || !isParam("-sl", argc, argv) ||
+       !isParam("-ml", argc, argv) || !isParam("-d", argc, argv) || !isParam("-o", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int squaresX = atoi(getParam("-w", argc, argv).c_str());
+    int squaresY = atoi(getParam("-h", argc, argv).c_str());
+    int squareLength = atoi(getParam("-sl", argc, argv).c_str());
+    int markerLength = atoi(getParam("-ml", argc, argv).c_str());
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    int margins = squareLength - markerLength;
+    if(isParam("-m", argc, argv)) {
+        margins = atoi(getParam("-m", argc, argv).c_str());
+    }
+
+    int borderBits = 1;
+    if(isParam("-bb", argc, argv)) {
+        borderBits = atoi(getParam("-bb", argc, argv).c_str());
+    }
+
+    bool showImage = false;
+    if(isParam("-si", argc, argv)) showImage = true;
+
+    Size imageSize;
+    imageSize.width = squaresX * squareLength + 2 * margins;
+    imageSize.height = squaresY * squareLength + 2 * margins;
+
+    aruco::CharucoBoard board = aruco::CharucoBoard::create(squaresX, squaresY, (float)squareLength,
+                                                            (float)markerLength, dictionary);
+
+    // show created board
+    Mat boardImage;
+    board.draw(imageSize, boardImage, margins, borderBits);
+
+    if(showImage) {
+        imshow("board", boardImage);
+        waitKey(0);
+    }
+
+    imwrite(getParam("-o", argc, argv), boardImage);
+
+    return 0;
+}

modules/aruco/samples/create_diamond.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco/charuco.hpp>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Create a ChArUco marker image" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-o <image> # Output image" << endl;
+    cout << "-sl <squareLength> # Square side lenght (in pixels)" << endl;
+    cout << "-ml <markerLength> # Marker side lenght (in pixels)" << endl;
+    cout << "-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" << endl;
+    cout << "-ids <id1,id2,id3,id4> # Four ids for the ChArUco marker" << endl;
+    cout << "[-m <marginSize>] # Margins size (in pixels). Default is 0" << endl;
+    cout << "[-bb <int>] # Number of bits in marker borders. Default is 1" << endl;
+    cout << "[-si] # show generated image" << endl;
+}
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-sl", argc, argv) || !isParam("-ml", argc, argv) || !isParam("-d", argc, argv) ||
+       !isParam("-ids", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int squareLength = atoi(getParam("-sl", argc, argv).c_str());
+    int markerLength = atoi(getParam("-ml", argc, argv).c_str());
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    string idsString = getParam("-ids", argc, argv);
+    istringstream ss(idsString);
+    vector< string > splittedIds;
+    string token;
+    while(getline(ss, token, ','))
+        splittedIds.push_back(token);
+    if(splittedIds.size() < 4) {
+        cerr << "Incorrect ids format" << endl;
+        help();
+        return 0;
+    }
+    Vec4i ids;
+    for(int i = 0; i < 4; i++)
+        ids[i] = atoi(splittedIds[i].c_str());
+
+    int margins = 0;
+    if(isParam("-m", argc, argv)) {
+        margins = atoi(getParam("-m", argc, argv).c_str());
+    }
+
+    int borderBits = 1;
+    if(isParam("-bb", argc, argv)) {
+        borderBits = atoi(getParam("-bb", argc, argv).c_str());
+    }
+
+    bool showImage = false;
+    if(isParam("-si", argc, argv)) showImage = true;
+
+    Mat markerImg;
+    aruco::drawCharucoDiamond(dictionary, ids, squareLength, markerLength, markerImg, margins,
+                              borderBits);
+
+    if(showImage) {
+        imshow("board", markerImg);
+        waitKey(0);
+    }
+
+    imwrite(getParam("-o", argc, argv), markerImg);
+
+    return 0;
+}

modules/aruco/samples/create_marker.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Create an ArUco marker image" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-o <image> # Output image" << endl;
+    cout << "-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" << endl;
+    cout << "-id <int> # Marker id in the dictionary" << endl;
+    cout << "[-ms <int>] # Marker size in pixels. Default is 200" << endl;
+    cout << "[-bb <int>] # Number of bits in marker borders. Default is 1" << endl;
+    cout << "[-si] # show generated image" << endl;
+}
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-d", argc, argv) || !isParam("-o", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    int markerId = atoi(getParam("-id", argc, argv).c_str());
+
+    int borderBits = 1;
+    if(isParam("-bb", argc, argv)) {
+        borderBits = atoi(getParam("-bb", argc, argv).c_str());
+    }
+
+    int markerSize = 200;
+    if(isParam("-ms", argc, argv)) {
+        markerSize = atoi(getParam("-ms", argc, argv).c_str());
+    }
+
+    bool showImage = false;
+    if(isParam("-si", argc, argv)) showImage = true;
+
+    Mat markerImg;
+    aruco::drawMarker(dictionary, markerId, markerSize, markerImg, borderBits);
+
+    if(showImage) {
+        imshow("marker", markerImg);
+        waitKey(0);
+    }
+
+    imwrite(getParam("-o", argc, argv), markerImg);
+
+    return 0;
+}

modules/aruco/samples/detect_board.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco.hpp>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Pose estimation using a ArUco Planar Grid board" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-w <nmarkers> # Number of markers in X direction" << endl;
+    cout << "-h <nmarkers> # Number of markers in Y direction" << endl;
+    cout << "-l <markerLength> # Marker side lenght (in meters)" << endl;
+    cout << "-s <markerSeparation> # Separation between two consecutive"
+         << "markers in the grid (in meters)" << endl;
+    cout << "-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" << endl;
+    cout << "-c <cameraParams> # Camera intrinsic parameters file" << endl;
+    cout << "[-v <videoFile>] # Input from video file, if ommited, input comes from camera" << endl;
+    cout << "[-ci <int>] # Camera id if input doesnt come from video (-v). Default is 0" << endl;
+    cout << "[-dp <detectorParams>] # File of marker detector parameters" << endl;
+    cout << "[-rs] # Apply refind strategy" << endl;
+    cout << "[-r] # show rejected candidates too" << endl;
+}
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+/**
+ */
+static bool readCameraParameters(string filename, Mat &camMatrix, Mat &distCoeffs) {
+    FileStorage fs(filename, FileStorage::READ);
+    if(!fs.isOpened())
+        return false;
+    fs["camera_matrix"] >> camMatrix;
+    fs["distortion_coefficients"] >> distCoeffs;
+    return true;
+}
+
+
+
+/**
+ */
+static bool readDetectorParameters(string filename, aruco::DetectorParameters &params) {
+    FileStorage fs(filename, FileStorage::READ);
+    if(!fs.isOpened())
+        return false;
+    fs["adaptiveThreshWinSizeMin"] >> params.adaptiveThreshWinSizeMin;
+    fs["adaptiveThreshWinSizeMax"] >> params.adaptiveThreshWinSizeMax;
+    fs["adaptiveThreshWinSizeStep"] >> params.adaptiveThreshWinSizeStep;
+    fs["adaptiveThreshConstant"] >> params.adaptiveThreshConstant;
+    fs["minMarkerPerimeterRate"] >> params.minMarkerPerimeterRate;
+    fs["maxMarkerPerimeterRate"] >> params.maxMarkerPerimeterRate;
+    fs["polygonalApproxAccuracyRate"] >> params.polygonalApproxAccuracyRate;
+    fs["minCornerDistanceRate"] >> params.minCornerDistanceRate;
+    fs["minDistanceToBorder"] >> params.minDistanceToBorder;
+    fs["minMarkerDistanceRate"] >> params.minMarkerDistanceRate;
+    fs["doCornerRefinement"] >> params.doCornerRefinement;
+    fs["cornerRefinementWinSize"] >> params.cornerRefinementWinSize;
+    fs["cornerRefinementMaxIterations"] >> params.cornerRefinementMaxIterations;
+    fs["cornerRefinementMinAccuracy"] >> params.cornerRefinementMinAccuracy;
+    fs["markerBorderBits"] >> params.markerBorderBits;
+    fs["perspectiveRemovePixelPerCell"] >> params.perspectiveRemovePixelPerCell;
+    fs["perspectiveRemoveIgnoredMarginPerCell"] >> params.perspectiveRemoveIgnoredMarginPerCell;
+    fs["maxErroneousBitsInBorderRate"] >> params.maxErroneousBitsInBorderRate;
+    fs["minOtsuStdDev"] >> params.minOtsuStdDev;
+    fs["errorCorrectionRate"] >> params.errorCorrectionRate;
+    return true;
+}
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-w", argc, argv) || !isParam("-h", argc, argv) || !isParam("-l", argc, argv) ||
+       !isParam("-s", argc, argv) || !isParam("-d", argc, argv) || !isParam("-c", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int markersX = atoi(getParam("-w", argc, argv).c_str());
+    int markersY = atoi(getParam("-h", argc, argv).c_str());
+    float markerLength = (float)atof(getParam("-l", argc, argv).c_str());
+    float markerSeparation = (float)atof(getParam("-s", argc, argv).c_str());
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    bool showRejected = false;
+    if(isParam("-r", argc, argv)) showRejected = true;
+
+    Mat camMatrix, distCoeffs;
+    if(isParam("-c", argc, argv)) {
+        bool readOk = readCameraParameters(getParam("-c", argc, argv), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            return 0;
+        }
+    }
+
+    aruco::DetectorParameters detectorParams;
+    if(isParam("-dp", argc, argv)) {
+        bool readOk = readDetectorParameters(getParam("-dp", argc, argv), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+    detectorParams.doCornerRefinement = true; // do corner refinement in markers
+
+    bool refindStrategy = false;
+    if(isParam("-rs", argc, argv)) refindStrategy = true;
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(isParam("-v", argc, argv)) {
+        inputVideo.open(getParam("-v", argc, argv));
+        waitTime = 0;
+    } else {
+        int camId = 0;
+        if(isParam("-ci", argc, argv)) camId = atoi(getParam("-ci", argc, argv).c_str());
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    float axisLength = 0.5f * ((float)min(markersX, markersY) * (markerLength + markerSeparation) +
+                               markerSeparation);
+
+    // create board object
+    aruco::GridBoard board =
+        aruco::GridBoard::create(markersX, markersY, markerLength, markerSeparation, dictionary);
+
+    double totalTime = 0;
+    int totalIterations = 0;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        vector< int > ids;
+        vector< vector< Point2f > > corners, rejected;
+        Mat rvec, tvec;
+
+        // detect markers
+        aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
+
+        // refind strategy to detect more markers
+        if(refindStrategy)
+            aruco::refineDetectedMarkers(image, board, corners, ids, rejected, camMatrix,
+                                         distCoeffs);
+
+        // estimate board pose
+        int markersOfBoardDetected = 0;
+        if(ids.size() > 0)
+            markersOfBoardDetected =
+                aruco::estimatePoseBoard(corners, ids, board, camMatrix, distCoeffs, rvec, tvec);
+
+        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(ids.size() > 0) {
+            aruco::drawDetectedMarkers(imageCopy, corners, ids);
+        }
+
+        if(showRejected && rejected.size() > 0)
+            aruco::drawDetectedMarkers(imageCopy, rejected, noArray(), Scalar(100, 0, 255));
+
+        if(markersOfBoardDetected > 0)
+            aruco::drawAxis(imageCopy, camMatrix, distCoeffs, rvec, tvec, axisLength);
+
+        imshow("out", imageCopy);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+    }
+
+    return 0;
+}

modules/aruco/samples/detect_markers.cpp

+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/aruco.hpp>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+/**
+ */
+static void help() {
+    cout << "Basic marker detection" << endl;
+    cout << "Parameters: " << endl;
+    cout << "-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" << endl;
+    cout << "[-v <videoFile>] # Input from video file, if ommited, input comes from camera" << endl;
+    cout << "[-ci <int>] # Camera id if input doesnt come from video (-v). Default is 0" << endl;
+    cout << "[-c <cameraParams>] # Camera intrinsic parameters. Needed for camera pose" << endl;
+    cout << "[-l <markerLength>] # Marker side lenght (in meters). Needed for correct"
+         << "scale in camera pose, default 0.1" << endl;
+    cout << "[-dp <detectorParams>] # File of marker detector parameters" << endl;
+    cout << "[-r] # show rejected candidates too" << endl;
+}
+
+
+
+/**
+ */
+static bool isParam(string param, int argc, char **argv) {
+    for(int i = 0; i < argc; i++)
+        if(string(argv[i]) == param) return true;
+    return false;
+}
+
+
+/**
+ */
+static string getParam(string param, int argc, char **argv, string defvalue = "") {
+    int idx = -1;
+    for(int i = 0; i < argc && idx == -1; i++)
+        if(string(argv[i]) == param) idx = i;
+    if(idx == -1 || (idx + 1) >= argc)
+        return defvalue;
+    else
+        return argv[idx + 1];
+}
+
+
+
+/**
+ */
+static bool readCameraParameters(string filename, Mat &camMatrix, Mat &distCoeffs) {
+    FileStorage fs(filename, FileStorage::READ);
+    if(!fs.isOpened())
+        return false;
+    fs["camera_matrix"] >> camMatrix;
+    fs["distortion_coefficients"] >> distCoeffs;
+    return true;
+}
+
+
+
+/**
+ */
+static bool readDetectorParameters(string filename, aruco::DetectorParameters &params) {
+    FileStorage fs(filename, FileStorage::READ);
+    if(!fs.isOpened())
+        return false;
+    fs["adaptiveThreshWinSizeMin"] >> params.adaptiveThreshWinSizeMin;
+    fs["adaptiveThreshWinSizeMax"] >> params.adaptiveThreshWinSizeMax;
+    fs["adaptiveThreshWinSizeStep"] >> params.adaptiveThreshWinSizeStep;
+    fs["adaptiveThreshConstant"] >> params.adaptiveThreshConstant;
+    fs["minMarkerPerimeterRate"] >> params.minMarkerPerimeterRate;
+    fs["maxMarkerPerimeterRate"] >> params.maxMarkerPerimeterRate;
+    fs["polygonalApproxAccuracyRate"] >> params.polygonalApproxAccuracyRate;
+    fs["minCornerDistanceRate"] >> params.minCornerDistanceRate;
+    fs["minDistanceToBorder"] >> params.minDistanceToBorder;
+    fs["minMarkerDistanceRate"] >> params.minMarkerDistanceRate;
+    fs["doCornerRefinement"] >> params.doCornerRefinement;
+    fs["cornerRefinementWinSize"] >> params.cornerRefinementWinSize;
+    fs["cornerRefinementMaxIterations"] >> params.cornerRefinementMaxIterations;
+    fs["cornerRefinementMinAccuracy"] >> params.cornerRefinementMinAccuracy;
+    fs["markerBorderBits"] >> params.markerBorderBits;
+    fs["perspectiveRemovePixelPerCell"] >> params.perspectiveRemovePixelPerCell;
+    fs["perspectiveRemoveIgnoredMarginPerCell"] >> params.perspectiveRemoveIgnoredMarginPerCell;
+    fs["maxErroneousBitsInBorderRate"] >> params.maxErroneousBitsInBorderRate;
+    fs["minOtsuStdDev"] >> params.minOtsuStdDev;
+    fs["errorCorrectionRate"] >> params.errorCorrectionRate;
+    return true;
+}
+
+
+
+/**
+ */
+int main(int argc, char *argv[]) {
+
+    if(!isParam("-d", argc, argv)) {
+        help();
+        return 0;
+    }
+
+    int dictionaryId = atoi(getParam("-d", argc, argv).c_str());
+    aruco::Dictionary dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    bool showRejected = false;
+    if(isParam("-r", argc, argv)) showRejected = true;
+
+    bool estimatePose = false;
+    Mat camMatrix, distCoeffs;
+    if(isParam("-c", argc, argv)) {
+        bool readOk = readCameraParameters(getParam("-c", argc, argv), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            return 0;
+        }
+        estimatePose = true;
+    }
+    float markerLength = (float)atof(getParam("-l", argc, argv, "0.1").c_str());
+
+    aruco::DetectorParameters detectorParams;
+    if(isParam("-dp", argc, argv)) {
+        bool readOk = readDetectorParameters(getParam("-dp", argc, argv), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+    detectorParams.doCornerRefinement = true; // do corner refinement in markers
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(isParam("-v", argc, argv)) {
+        inputVideo.open(getParam("-v", argc, argv));
+        waitTime = 0;
+    } else {
+        int camId = 0;
+        if(isParam("-ci", argc, argv)) camId = atoi(getParam("-ci", argc, argv).c_str());
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    double totalTime = 0;
+    int totalIterations = 0;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        vector< int > ids;
+        vector< vector< Point2f > > corners, rejected;
+        vector< Mat > rvecs, tvecs;
+
+        // detect markers and estimate pose
+        aruco::detectMarkers(image, dictionary, corners, ids, detectorParams, rejected);
+        if(estimatePose && ids.size() > 0)
+            aruco::estimatePoseSingleMarkers(corners, markerLength, camMatrix, distCoeffs, rvecs,
+                                             tvecs);
+
+        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(ids.size() > 0) {
+            aruco::drawDetectedMarkers(imageCopy, corners, ids);
+
+            if(estimatePose) {
+                for(unsigned int i = 0; i < ids.size(); i++)
+                    aruco::drawAxis(imageCopy, camMatrix, distCoeffs, rvecs[i], tvecs[i],
+                                    markerLength * 0.5f);
+            }
+        }
+
+        if(showRejected && rejected.size() > 0)
+            aruco::drawDetectedMarkers(imageCopy, rejected, noArray(), Scalar(100, 0, 255));
+
+        imshow("out", imageCopy);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+    }
+
+    return 0;
+}

modules/aruco/samples/detector_params.yml

+%YAML:1.0
+nmarkers: 1024
+adaptiveThreshWinSize: 21
+adaptiveThreshConstant: 7
+minMarkerPerimeterRate: 0.03
+maxMarkerPerimeterRate: 4.0
+polygonalApproxAccuracyRate: 0.05
+minCornerDistance: 10.0
+minDistanceToBorder: 3
+minMarkerDistance: 10.0
+cornerRefinementWinSize: 5
+cornerRefinementMaxIterations: 30
+cornerRefinementMinAccuracy: 0.1
+markerBorderBits: 1
+perspectiveRemovePixelPerCell: 8
+perspectiveRemoveIgnoredMarginPerCell: 0.13
+maxErroneousBitsInBorderRate: 0.04

modules/aruco/src/precomp.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2014, OpenCV Foundation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef __OPENCV_CCALIB_PRECOMP__
+#define __OPENCV_CCALIB_PRECOMP__
+
+#include <opencv2/core.hpp>
+#include <opencv2/calib3d.hpp>
+#include <vector>
+
+#endif

modules/aruco/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/aruco/test/test_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include <iostream>
+#include "opencv2/ts.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/aruco.hpp"
+
+#endif

modules/aruco/tutorials/table_of_content_aruco.markdown

+ArUco marker detection (aruco module) {#tutorial_table_of_content_aruco}
+==========================================================
+
+ArUco markers are binary square fiducial markers that can be used for camera pose estimation.
+Their main benefit is that their detection is robust, fast and simple.
+
+The aruco module includes the detection of these types of markers and the tools to employ them
+for pose estimation and camera calibration.
+
+Also, the ChArUco functionalities combine ArUco markers with traditional chessboards to allow
+an easy and versatile corner detection. The module also includes the functions to detect
+ChArUco corners and use them for pose estimation and camera calibration.
+
+-   @subpage tutorial_aruco_detection
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    Basic detection and pose estimation from single ArUco markers.
+
+-   @subpage tutorial_aruco_board_detection
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    Detection and pose estimation using a Board of markers
+
+-   @subpage tutorial_charuco_detection
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    Basic detection using ChArUco corners
+
+-   @subpage tutorial_charuco_diamond_detection
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    Detection and pose estimation using ChArUco markers
+
+-   @subpage tutorial_aruco_calibration
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    Camera Calibration using ArUco and ChArUco boards
+
+-   @subpage tutorial_aruco_faq
+
+    *Compatibility:* \> OpenCV 3.0
+
+    *Author:* Sergio Garrido
+
+    General and useful questions about the aruco module