aruco_pose: Vendor opencv_contrib/aruco again

.gitattributes

@@ -3,3 +3,4 @@ roslib.js linguist-vendored
 eventemitter2.js linguist-vendored
 ros3d.js linguist-vendored
 three.min.js linguist-vendored
+aruco_pose/vendor/* linguist-vendored

.travis.yml

@@ -93,7 +93,7 @@ jobs:
         - wget https://github.com/okalachev/editorconfig-checker/releases/download/1.2.1-disable-spaces-amount/ec-linux-amd64
         - chmod +x ec-linux-amd64
       script:
-        - ./ec-linux-amd64 -spaces-after-tabs -e "roslib.js|ros3d.js|eventemitter2.js|draw.cpp|BinUtils.swift|\.idea|apps/android/app|Assets.xcassets|test_parser_pass.txt|test_node_failure.txt|aruco_pose/src/aruco_lib/aruco"
+        - ./ec-linux-amd64 -spaces-after-tabs -e "roslib.js|ros3d.js|eventemitter2.js|draw.cpp|BinUtils.swift|\.idea|apps/android/app|Assets.xcassets|test_parser_pass.txt|test_node_failure.txt|aruco_pose/vendor"
 stages:
   - Build
   - Annotate

aruco_pose/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.3)
+cmake_minimum_required(VERSION 3.0)
 project(aruco_pose)
 
 add_definitions(-std=c++11 -Wall -g)
@@ -23,7 +23,16 @@ find_package(catkin REQUIRED COMPONENTS
   message_generation
 )
 
-find_package(OpenCV 3 REQUIRED)
+find_package(OpenCV 3 REQUIRED COMPONENTS core imgproc calib3d)
+if ("${OpenCV_VERSION_MINOR}" LESS "3")
+  message(STATUS "OpenCV version too low, using vendored ArUco package")
+  include(vendor/VendorOpenCV.cmake)
+else()
+  message(STATUS "Using system OpenCV ArUco package")
+  find_package(OpenCV 3 REQUIRED COMPONENTS aruco)
+endif()
+message(STATUS "OpenCV include dirs: ${OpenCV_INCLUDE_DIRS}")
+message(STATUS "OpenCV libraries: ${OpenCV_LIBRARIES}")
 
 ## System dependencies are found with CMake's conventions
 # find_package(Boost REQUIRED COMPONENTS system)

aruco_pose/vendor/VendorOpenCV.cmake

@@ -0,0 +1,33 @@
+# There should be a better way to add ArUco libraries,
+# but I have not found it yet.
+#  -- sfalexrog, 2019.09.11
+if (NOT OpenCV_LIBRARIES OR NOT OpenCV_INCLUDE_DIRS)
+  message(FATAL_ERROR "OpenCV was not found - cannot continue")
+endif()
+
+message(STATUS "Adding vendored aruco_pose OpenCV module")
+add_library(_opencv_aruco STATIC
+  vendor/aruco/src/aruco.cpp
+  vendor/aruco/src/charuco.cpp
+  vendor/aruco/src/dictionary.cpp
+  vendor/aruco/src/zmaxheap.cpp
+  )
+
+target_include_directories(_opencv_aruco PRIVATE
+  ${OpenCV_INCLUDE_DIRS}
+)
+target_link_libraries(_opencv_aruco PRIVATE
+  ${OpenCV_LIBRARIES}
+)
+target_compile_definitions(_opencv_aruco PRIVATE
+  CV_OVERRIDE=override
+)
+target_compile_options(_opencv_aruco PRIVATE
+  -fpic -fPIC
+)
+
+target_include_directories(_opencv_aruco PUBLIC
+  vendor/aruco/include
+)
+
+set(OpenCV_LIBRARIES "_opencv_aruco;${OpenCV_LIBRARIES}")

aruco_pose/vendor/aruco/CMakeLists.txt

@@ -0,0 +1,2 @@
+set(the_description "ArUco Marker Detection")
+ocv_define_module(aruco opencv_core opencv_imgproc opencv_calib3d WRAP python java)

aruco_pose/vendor/aruco/README.md

@@ -0,0 +1,12 @@
+ArUco Marker Detection
+======================
+
+**ArUco**
+
+ArUco markers are easy to detect pattern grids that yield up to 1024 different patterns. They were built for augmented reality and later used for camera calibration. Since the grid uniquely orients the square, the detection algorithm can determing the pose of the grid.
+
+**ChArUco**
+
+ArUco markers were improved by interspersing them inside a checkerboard called ChArUco. Checkerboard corner intersectionsa provide more stable corners because the edge location bias on one square is countered by the opposite edge orientation in the connecting square. By interspersing ArUco markers inside the checkerboard, each checkerboard corner gets a label which enables it to be used in complex calibration or pose scenarios where you cannot see all the corners of the checkerboard.
+
+The smallest ChArUco board is 5 checkers and 4 markers called a "Diamond Marker".

aruco_pose/vendor/aruco/doc/aruco.bib

@@ -0,0 +1,21 @@
+@article{Aruco2014,
+ title = "Automatic generation and detection of highly reliable fiducial markers under occlusion ",
+ journal = "Pattern Recognition ",
+ volume = "47",
+ number = "6",
+ pages = "2280 - 2292",
+ year = "2014",
+ issn = "0031-3203",
+ doi = "http://dx.doi.org/10.1016/j.patcog.2014.01.005",
+ url = "http://www.sciencedirect.com/science/article/pii/S0031320314000235",
+ author = "S. Garrido-Jurado and R. Mu\~noz-Salinas and F.J. Madrid-Cuevas and M.J. Mar\'in-Jim\'enez"
+}
+
+@inproceedings{wang2016iros,
+    AUTHOR     = {John Wang and Edwin Olson},
+    TITLE      = {{AprilTag} 2: Efficient and robust fiducial detection},
+    BOOKTITLE  = {Proceedings of the {IEEE/RSJ} International Conference on Intelligent
+                 Robots and Systems {(IROS)}},
+    YEAR       = {2016},
+    MONTH      = {October},
+}

aruco_pose/vendor/aruco/include/opencv2/aruco.hpp

@@ -0,0 +1,604 @@
+/*
+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_ARUCO_HPP__
+#define __OPENCV_ARUCO_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+#include "opencv2/aruco/dictionary.hpp"
+
+/**
+ * @defgroup aruco ArUco Marker Detection
+ * This module is dedicated to square fiducial markers (also known as Augmented Reality Markers)
+ * These markers are useful for easy, fast and robust camera pose estimation.ç
+ *
+ * The main functionalities are:
+ * - Detection of markers in an image
+ * - Pose estimation from a single marker or from a board/set of markers
+ * - Detection of ChArUco board for high subpixel accuracy
+ * - Camera calibration from both, ArUco boards and ChArUco boards.
+ * - Detection of ChArUco diamond markers
+ * The samples directory includes easy examples of how to use the module.
+ *
+ * The implementation is based on the ArUco Library by R. Muñoz-Salinas and S. Garrido-Jurado @cite Aruco2014.
+ *
+ * Markers can also be detected based on the AprilTag 2 @cite wang2016iros fiducial detection method.
+ *
+ * @sa S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+ * "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+ * Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+ *
+ * @sa http://www.uco.es/investiga/grupos/ava/node/26
+ *
+ * This module has been originally developed by Sergio Garrido-Jurado as a project
+ * for Google Summer of Code 2015 (GSoC 15).
+ *
+ *
+*/
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup aruco
+//! @{
+
+enum CornerRefineMethod{
+    CORNER_REFINE_NONE,     ///< Tag and corners detection based on the ArUco approach
+    CORNER_REFINE_SUBPIX,   ///< ArUco approach and refine the corners locations using corner subpixel accuracy
+    CORNER_REFINE_CONTOUR,  ///< ArUco approach and refine the corners locations using the contour-points line fitting
+    CORNER_REFINE_APRILTAG, ///< Tag and corners detection based on the AprilTag 2 approach @cite wang2016iros
+};
+
+/**
+ * @brief Parameters for the detectMarker process:
+ * - adaptiveThreshWinSizeMin: minimum window size for adaptive thresholding before finding
+ *   contours (default 3).
+ * - adaptiveThreshWinSizeMax: maximum window size for adaptive thresholding before finding
+ *   contours (default 23).
+ * - adaptiveThreshWinSizeStep: increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax
+ *   during the thresholding (default 10).
+ * - adaptiveThreshConstant: constant for adaptive thresholding before finding contours (default 7)
+ * - minMarkerPerimeterRate: determine minimum perimeter for marker contour to be detected. This
+ *   is defined as a rate respect to the maximum dimension of the input image (default 0.03).
+ * - maxMarkerPerimeterRate:  determine maximum perimeter for marker contour to be detected. This
+ *   is defined as a rate respect to the maximum dimension of the input image (default 4.0).
+ * - polygonalApproxAccuracyRate: minimum accuracy during the polygonal approximation process to
+ *   determine which contours are squares.
+ * - minCornerDistanceRate: minimum distance between corners for detected markers relative to its
+ *   perimeter (default 0.05)
+ * - minDistanceToBorder: minimum distance of any corner to the image border for detected markers
+ *   (in pixels) (default 3)
+ * - minMarkerDistanceRate: minimum mean distance beetween two marker corners to be considered
+ *   similar, so that the smaller one is removed. The rate is relative to the smaller perimeter
+ *   of the two markers (default 0.05).
+ * - cornerRefinementMethod: corner refinement method. (CORNER_REFINE_NONE, no refinement.
+ *   CORNER_REFINE_SUBPIX, do subpixel refinement. CORNER_REFINE_CONTOUR use contour-Points,
+ *   CORNER_REFINE_APRILTAG  use the AprilTag2 approach)
+ * - cornerRefinementWinSize: window size for the corner refinement process (in pixels) (default 5).
+ * - cornerRefinementMaxIterations: maximum number of iterations for stop criteria of the corner
+ *   refinement process (default 30).
+ * - cornerRefinementMinAccuracy: minimum error for the stop cristeria of the corner refinement
+ *   process (default: 0.1)
+ * - markerBorderBits: number of bits of the marker border, i.e. marker border width (default 1).
+ * - perspectiveRemovePixelPerCell: number of bits (per dimension) for each cell of the marker
+ *   when removing the perspective (default 8).
+ * - perspectiveRemoveIgnoredMarginPerCell: width of the margin of pixels on each cell not
+ *   considered for the determination of the cell bit. Represents the rate respect to the total
+ *   size of the cell, i.e. perspectiveRemovePixelPerCell (default 0.13)
+ * - maxErroneousBitsInBorderRate: maximum number of accepted erroneous bits in the border (i.e.
+ *   number of allowed white bits in the border). Represented as a rate respect to the total
+ *   number of bits per marker (default 0.35).
+ * - minOtsuStdDev: minimun standard deviation in pixels values during the decodification step to
+ *   apply Otsu thresholding (otherwise, all the bits are set to 0 or 1 depending on mean higher
+ *   than 128 or not) (default 5.0)
+ * - errorCorrectionRate error correction rate respect to the maximun error correction capability
+ *   for each dictionary. (default 0.6).
+ * - aprilTagMinClusterPixels: reject quads containing too few pixels.
+ * - aprilTagMaxNmaxima: how many corner candidates to consider when segmenting a group of pixels into a quad.
+ * - aprilTagCriticalRad: Reject quads where pairs of edges have angles that are close to straight or close to
+ *   180 degrees. Zero means that no quads are rejected. (In radians).
+ * - aprilTagMaxLineFitMse:  When fitting lines to the contours, what is the maximum mean squared error
+ *   allowed?  This is useful in rejecting contours that are far from being quad shaped; rejecting
+ *   these quads "early" saves expensive decoding processing.
+ * - aprilTagMinWhiteBlackDiff: When we build our model of black & white pixels, we add an extra check that
+ *   the white model must be (overall) brighter than the black model.  How much brighter? (in pixel values, [0,255]).
+ * - aprilTagDeglitch:  should the thresholded image be deglitched? Only useful for very noisy images
+ * - aprilTagQuadDecimate: Detection of quads can be done on a lower-resolution image, improving speed at a
+ *   cost of pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still
+ *   done at full resolution.
+ * - aprilTagQuadSigma: What Gaussian blur should be applied to the segmented image (used for quad detection?)
+ *   Parameter is the standard deviation in pixels.  Very noisy images benefit from non-zero values (e.g. 0.8).
+ * - detectInvertedMarker: to check if there is a white marker. In order to generate a "white" marker just
+ *   invert a normal marker by using a tilde, ~markerImage. (default false)
+ */
+struct CV_EXPORTS_W DetectorParameters {
+
+    DetectorParameters();
+
+    CV_WRAP static Ptr<DetectorParameters> create();
+
+    CV_PROP_RW int adaptiveThreshWinSizeMin;
+    CV_PROP_RW int adaptiveThreshWinSizeMax;
+    CV_PROP_RW int adaptiveThreshWinSizeStep;
+    CV_PROP_RW double adaptiveThreshConstant;
+    CV_PROP_RW double minMarkerPerimeterRate;
+    CV_PROP_RW double maxMarkerPerimeterRate;
+    CV_PROP_RW double polygonalApproxAccuracyRate;
+    CV_PROP_RW double minCornerDistanceRate;
+    CV_PROP_RW int minDistanceToBorder;
+    CV_PROP_RW double minMarkerDistanceRate;
+    CV_PROP_RW int cornerRefinementMethod;
+    CV_PROP_RW int cornerRefinementWinSize;
+    CV_PROP_RW int cornerRefinementMaxIterations;
+    CV_PROP_RW double cornerRefinementMinAccuracy;
+    CV_PROP_RW int markerBorderBits;
+    CV_PROP_RW int perspectiveRemovePixelPerCell;
+    CV_PROP_RW double perspectiveRemoveIgnoredMarginPerCell;
+    CV_PROP_RW double maxErroneousBitsInBorderRate;
+    CV_PROP_RW double minOtsuStdDev;
+    CV_PROP_RW double errorCorrectionRate;
+
+    // April :: User-configurable parameters.
+    CV_PROP_RW float aprilTagQuadDecimate;
+    CV_PROP_RW float aprilTagQuadSigma;
+
+    // April :: Internal variables
+    CV_PROP_RW int aprilTagMinClusterPixels;
+    CV_PROP_RW int aprilTagMaxNmaxima;
+    CV_PROP_RW float aprilTagCriticalRad;
+    CV_PROP_RW float aprilTagMaxLineFitMse;
+    CV_PROP_RW int aprilTagMinWhiteBlackDiff;
+    CV_PROP_RW int aprilTagDeglitch;
+
+    // to detect white (inverted) markers
+    CV_PROP_RW bool detectInvertedMarker;
+};
+
+
+
+/**
+ * @brief Basic marker detection
+ *
+ * @param image input image
+ * @param dictionary indicates the type of markers that will be searched
+ * @param corners vector of detected marker corners. For each marker, its four corners
+ * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+ * the dimensions of this array is Nx4. The order of the corners is clockwise.
+ * @param ids vector of identifiers of the detected markers. The identifier is of type int
+ * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+ * The identifiers have the same order than the markers in the imgPoints array.
+ * @param parameters marker detection parameters
+ * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+ * correct codification. Useful for debugging purposes.
+ * @param cameraMatrix optional input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeff optional vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ *
+ * Performs marker detection in the input image. Only markers included in the specific dictionary
+ * are searched. For each detected marker, it returns the 2D position of its corner in the image
+ * and its corresponding identifier.
+ * Note that this function does not perform pose estimation.
+ * @sa estimatePoseSingleMarkers,  estimatePoseBoard
+ *
+ */
+CV_EXPORTS_W void detectMarkers(InputArray image, const Ptr<Dictionary> &dictionary, OutputArrayOfArrays corners,
+                                OutputArray ids, const Ptr<DetectorParameters> &parameters = DetectorParameters::create(),
+                                OutputArrayOfArrays rejectedImgPoints = noArray(), InputArray cameraMatrix= noArray(), InputArray distCoeff= noArray());
+
+
+
+/**
+ * @brief Pose estimation for single markers
+ *
+ * @param corners vector of already detected markers corners. For each marker, its four corners
+ * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+ * the dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @sa detectMarkers
+ * @param markerLength the length of the markers' side. The returning translation vectors will
+ * be in the same unit. Normally, unit is meters.
+ * @param cameraMatrix input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvecs array of output rotation vectors (@sa Rodrigues) (e.g. std::vector<cv::Vec3d>).
+ * Each element in rvecs corresponds to the specific marker in imgPoints.
+ * @param tvecs array of output translation vectors (e.g. std::vector<cv::Vec3d>).
+ * Each element in tvecs corresponds to the specific marker in imgPoints.
+ * @param _objPoints array of object points of all the marker corners
+ *
+ * This function receives the detected markers and returns their pose estimation respect to
+ * the camera individually. So for each marker, one rotation and translation vector is returned.
+ * The returned transformation is the one that transforms points from each marker coordinate system
+ * to the camera coordinate system.
+ * The marker corrdinate system is centered on the middle of the marker, with the Z axis
+ * perpendicular to the marker plane.
+ * The coordinates of the four corners of the marker in its own coordinate system are:
+ * (-markerLength/2, markerLength/2, 0), (markerLength/2, markerLength/2, 0),
+ * (markerLength/2, -markerLength/2, 0), (-markerLength/2, -markerLength/2, 0)
+ */
+CV_EXPORTS_W void estimatePoseSingleMarkers(InputArrayOfArrays corners, float markerLength,
+                                            InputArray cameraMatrix, InputArray distCoeffs,
+                                            OutputArray rvecs, OutputArray tvecs, OutputArray _objPoints = noArray());
+
+
+
+/**
+ * @brief Board of markers
+ *
+ * A board is a set of markers in the 3D space with a common coordinate system.
+ * The common form of a board of marker is a planar (2D) board, however any 3D layout can be used.
+ * A Board object is composed by:
+ * - The object points of the marker corners, i.e. their coordinates respect to the board system.
+ * - The dictionary which indicates the type of markers of the board
+ * - The identifier of all the markers in the board.
+ */
+class CV_EXPORTS_W Board {
+
+    public:
+    /**
+    * @brief Provide way to create Board by passing necessary data. Specially needed in Python.
+    *
+    * @param objPoints array of object points of all the marker corners in the board
+    * @param dictionary the dictionary of markers employed for this board
+    * @param ids vector of the identifiers of the markers in the board
+    *
+    */
+    CV_WRAP static Ptr<Board> create(InputArrayOfArrays objPoints, const Ptr<Dictionary> &dictionary, InputArray ids);
+    /// array of object points of all the marker corners in the board
+    /// each marker include its 4 corners in CCW order. For M markers, the size is Mx4.
+    CV_PROP std::vector< std::vector< Point3f > > objPoints;
+
+    /// the dictionary of markers employed for this board
+    CV_PROP Ptr<Dictionary> dictionary;
+
+    /// vector of the identifiers of the markers in the board (same size than objPoints)
+    /// The identifiers refers to the board dictionary
+    CV_PROP std::vector< int > ids;
+};
+
+
+
+/**
+ * @brief Planar board with grid arrangement of markers
+ * More common type of board. All markers are placed in the same plane in a grid arrangement.
+ * The board can be drawn using drawPlanarBoard() function (@sa drawPlanarBoard)
+ */
+class CV_EXPORTS_W GridBoard : public Board {
+
+    public:
+    /**
+     * @brief Draw a GridBoard
+     *
+     * @param outSize size of the output image in pixels.
+     * @param img output image with the board. The size of this image will be outSize
+     * and the board will be on the center, keeping the board proportions.
+     * @param marginSize minimum margins (in pixels) of the board in the output image
+     * @param borderBits width of the marker borders.
+     *
+     * This function return the image of the GridBoard, ready to be printed.
+     */
+    CV_WRAP void draw(Size outSize, OutputArray img, int marginSize = 0, int borderBits = 1);
+
+
+    /**
+     * @brief Create a GridBoard object
+     *
+     * @param markersX number of markers in X direction
+     * @param markersY number of markers in Y direction
+     * @param markerLength marker side length (normally in meters)
+     * @param markerSeparation separation between two markers (same unit as markerLength)
+     * @param dictionary dictionary of markers indicating the type of markers
+     * @param firstMarker id of first marker in dictionary to use on board.
+     * @return the output GridBoard object
+     *
+     * This functions creates a GridBoard object given the number of markers in each direction and
+     * the marker size and marker separation.
+     */
+    CV_WRAP static Ptr<GridBoard> create(int markersX, int markersY, float markerLength,
+                                         float markerSeparation, const Ptr<Dictionary> &dictionary, int firstMarker = 0);
+
+    /**
+      *
+      */
+    CV_WRAP Size getGridSize() const { return Size(_markersX, _markersY); }
+
+    /**
+      *
+      */
+    CV_WRAP float getMarkerLength() const { return _markerLength; }
+
+    /**
+      *
+      */
+    CV_WRAP float getMarkerSeparation() const { return _markerSeparation; }
+
+
+    private:
+    // number of markers in X and Y directions
+    int _markersX, _markersY;
+
+    // marker side lenght (normally in meters)
+    float _markerLength;
+
+    // separation between markers in the grid
+    float _markerSeparation;
+};
+
+
+
+/**
+ * @brief Pose estimation for a board of markers
+ *
+ * @param corners vector of already detected markers corners. For each marker, its four corners
+ * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the
+ * dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @param ids list of identifiers for each marker in corners
+ * @param board layout of markers in the board. The layout is composed by the marker identifiers
+ * and the positions of each marker corner in the board reference system.
+ * @param cameraMatrix input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvec Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board
+ * (see cv::Rodrigues). Used as initial guess if not empty.
+ * @param tvec Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.
+ * @param useExtrinsicGuess defines whether initial guess for \b rvec and \b tvec will be used or not.
+ * Used as initial guess if not empty.
+ *
+ * This function receives the detected markers and returns the pose of a marker board composed
+ * by those markers.
+ * A Board of marker has a single world coordinate system which is defined by the board layout.
+ * The returned transformation is the one that transforms points from the board coordinate system
+ * to the camera coordinate system.
+ * Input markers that are not included in the board layout are ignored.
+ * The function returns the number of markers from the input employed for the board pose estimation.
+ * Note that returning a 0 means the pose has not been estimated.
+ */
+CV_EXPORTS_W int estimatePoseBoard(InputArrayOfArrays corners, InputArray ids, const Ptr<Board> &board,
+                                   InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec,
+                                   OutputArray tvec, bool useExtrinsicGuess = false);
+
+
+
+
+/**
+ * @brief Refind not detected markers based on the already detected and the board layout
+ *
+ * @param image input image
+ * @param board layout of markers in the board.
+ * @param detectedCorners vector of already detected marker corners.
+ * @param detectedIds vector of already detected marker identifiers.
+ * @param rejectedCorners vector of rejected candidates during the marker detection process.
+ * @param cameraMatrix optional input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs optional vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param minRepDistance minimum distance between the corners of the rejected candidate and the
+ * reprojected marker in order to consider it as a correspondence.
+ * @param errorCorrectionRate rate of allowed erroneous bits respect to the error correction
+ * capability of the used dictionary. -1 ignores the error correction step.
+ * @param checkAllOrders Consider the four posible corner orders in the rejectedCorners array.
+ * If it set to false, only the provided corner order is considered (default true).
+ * @param recoveredIdxs Optional array to returns the indexes of the recovered candidates in the
+ * original rejectedCorners array.
+ * @param parameters marker detection parameters
+ *
+ * This function tries to find markers that were not detected in the basic detecMarkers function.
+ * First, based on the current detected marker and the board layout, the function interpolates
+ * the position of the missing markers. Then it tries to find correspondence between the reprojected
+ * markers and the rejected candidates based on the minRepDistance and errorCorrectionRate
+ * parameters.
+ * If camera parameters and distortion coefficients are provided, missing markers are reprojected
+ * using projectPoint function. If not, missing marker projections are interpolated using global
+ * homography, and all the marker corners in the board must have the same Z coordinate.
+ */
+CV_EXPORTS_W void refineDetectedMarkers(
+    InputArray image,const  Ptr<Board> &board, InputOutputArrayOfArrays detectedCorners,
+    InputOutputArray detectedIds, InputOutputArrayOfArrays rejectedCorners,
+    InputArray cameraMatrix = noArray(), InputArray distCoeffs = noArray(),
+    float minRepDistance = 10.f, float errorCorrectionRate = 3.f, bool checkAllOrders = true,
+    OutputArray recoveredIdxs = noArray(), const Ptr<DetectorParameters> &parameters = DetectorParameters::create());
+
+
+
+/**
+ * @brief Draw detected markers in image
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param corners positions of marker corners on input image.
+ * (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of
+ * this array should be Nx4. The order of the corners should be clockwise.
+ * @param ids vector of identifiers for markers in markersCorners .
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one to improve visualization.
+ *
+ * Given an array of detected marker corners and its corresponding ids, this functions draws
+ * the markers in the image. The marker borders are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedMarkers(InputOutputArray image, InputArrayOfArrays corners,
+                                      InputArray ids = noArray(),
+                                      Scalar borderColor = Scalar(0, 255, 0));
+
+
+
+/**
+ * @brief Draw coordinate system axis from pose estimation
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param cameraMatrix input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvec rotation vector of the coordinate system that will be drawn. (@sa Rodrigues).
+ * @param tvec translation vector of the coordinate system that will be drawn.
+ * @param length length of the painted axis in the same unit than tvec (usually in meters)
+ *
+ * Given the pose estimation of a marker or board, this function draws the axis of the world
+ * coordinate system, i.e. the system centered on the marker/board. Useful for debugging purposes.
+ *
+ * @deprecated use cv::drawFrameAxes
+ */
+CV_EXPORTS_W void drawAxis(InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs,
+                           InputArray rvec, InputArray tvec, float length);
+
+
+
+/**
+ * @brief Draw a canonical marker image
+ *
+ * @param dictionary dictionary of markers indicating the type of markers
+ * @param id identifier of the marker that will be returned. It has to be a valid id
+ * in the specified dictionary.
+ * @param sidePixels size of the image in pixels
+ * @param img output image with the marker
+ * @param borderBits width of the marker border.
+ *
+ * This function returns a marker image in its canonical form (i.e. ready to be printed)
+ */
+CV_EXPORTS_W void drawMarker(const Ptr<Dictionary> &dictionary, int id, int sidePixels, OutputArray img,
+                             int borderBits = 1);
+
+
+
+/**
+ * @brief Draw a planar board
+ * @sa _drawPlanarBoardImpl
+ *
+ * @param board layout of the board that will be drawn. The board should be planar,
+ * z coordinate is ignored
+ * @param outSize size of the output image in pixels.
+ * @param img output image with the board. The size of this image will be outSize
+ * and the board will be on the center, keeping the board proportions.
+ * @param marginSize minimum margins (in pixels) of the board in the output image
+ * @param borderBits width of the marker borders.
+ *
+ * This function return the image of a planar board, ready to be printed. It assumes
+ * the Board layout specified is planar by ignoring the z coordinates of the object points.
+ */
+CV_EXPORTS_W void drawPlanarBoard(const Ptr<Board> &board, Size outSize, OutputArray img,
+                                  int marginSize = 0, int borderBits = 1);
+
+
+
+/**
+ * @brief Implementation of drawPlanarBoard that accepts a raw Board pointer.
+ */
+void _drawPlanarBoardImpl(Board *board, Size outSize, OutputArray img,
+                          int marginSize = 0, int borderBits = 1);
+
+
+
+/**
+ * @brief Calibrate a camera using aruco markers
+ *
+ * @param corners vector of detected marker corners in all frames.
+ * The corners should have the same format returned by detectMarkers (see #detectMarkers).
+ * @param ids list of identifiers for each marker in corners
+ * @param counter number of markers in each frame so that corners and ids can be split
+ * @param board Marker Board layout
+ * @param imageSize Size of the image used only to initialize the intrinsic camera matrix.
+ * @param cameraMatrix Output 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV\_CALIB\_USE\_INTRINSIC\_GUESS
+ * and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be
+ * initialized before calling the function.
+ * @param distCoeffs Output vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each board view
+ * (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding
+ * k-th translation vector (see the next output parameter description) brings the board pattern
+ * from the model coordinate space (in which object points are specified) to the world coordinate
+ * space, that is, a real position of the board pattern in the k-th pattern view (k=0.. *M* -1).
+ * @param tvecs Output vector of translation vectors estimated for each pattern view.
+ * @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
+ * Order of deviations values:
+ * \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3,
+ * s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
+ * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
+ * Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views,
+ * \f$R_i, T_i\f$ are concatenated 1x3 vectors.
+ * @param perViewErrors Output vector of average re-projection errors estimated for each pattern view.
+ * @param flags flags Different flags  for the calibration process (see #calibrateCamera for details).
+ * @param criteria Termination criteria for the iterative optimization algorithm.
+ *
+ * This function calibrates a camera using an Aruco Board. The function receives a list of
+ * detected markers from several views of the Board. The process is similar to the chessboard
+ * calibration in calibrateCamera(). The function returns the final re-projection error.
+ */
+CV_EXPORTS_AS(calibrateCameraArucoExtended) double calibrateCameraAruco(
+    InputArrayOfArrays corners, InputArray ids, InputArray counter, const Ptr<Board> &board,
+    Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+    OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+    OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics,
+    OutputArray perViewErrors, int flags = 0,
+    TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
+
+
+/** @brief It's the same function as #calibrateCameraAruco but without calibration error estimation.
+ */
+CV_EXPORTS_W double calibrateCameraAruco(
+  InputArrayOfArrays corners, InputArray ids, InputArray counter, const Ptr<Board> &board,
+  Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+  OutputArrayOfArrays rvecs = noArray(), OutputArrayOfArrays tvecs = noArray(), int flags = 0,
+  TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
+
+
+/**
+ * @brief Given a board configuration and a set of detected markers, returns the corresponding
+ * image points and object points to call solvePnP
+ *
+ * @param board Marker board layout.
+ * @param detectedCorners List of detected marker corners of the board.
+ * @param detectedIds List of identifiers for each marker.
+ * @param objPoints Vector of vectors of board marker points in the board coordinate space.
+ * @param imgPoints Vector of vectors of the projections of board marker corner points.
+*/
+CV_EXPORTS_W void getBoardObjectAndImagePoints(const Ptr<Board> &board, InputArrayOfArrays detectedCorners,
+  InputArray detectedIds, OutputArray objPoints, OutputArray imgPoints);
+
+
+//! @}
+}
+}
+
+#endif

aruco_pose/vendor/aruco/include/opencv2/aruco/charuco.hpp

@@ -0,0 +1,343 @@
+/*
+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_CHARUCO_HPP__
+#define __OPENCV_CHARUCO_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+#include <opencv2/aruco.hpp>
+
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup aruco
+//! @{
+
+
+/**
+ * @brief ChArUco board
+ * Specific class for ChArUco boards. A ChArUco board is a planar board where the markers are placed
+ * inside the white squares of a chessboard. The benefits of ChArUco boards is that they provide
+ * both, ArUco markers versatility and chessboard corner precision, which is important for
+ * calibration and pose estimation.
+ * This class also allows the easy creation and drawing of ChArUco boards.
+ */
+class CV_EXPORTS_W CharucoBoard : public Board {
+
+    public:
+    // vector of chessboard 3D corners precalculated
+    CV_PROP std::vector< Point3f > chessboardCorners;
+
+    // for each charuco corner, nearest marker id and nearest marker corner id of each marker
+    CV_PROP std::vector< std::vector< int > > nearestMarkerIdx;
+    CV_PROP std::vector< std::vector< int > > nearestMarkerCorners;
+
+    /**
+     * @brief Draw a ChArUco board
+     *
+     * @param outSize size of the output image in pixels.
+     * @param img output image with the board. The size of this image will be outSize
+     * and the board will be on the center, keeping the board proportions.
+     * @param marginSize minimum margins (in pixels) of the board in the output image
+     * @param borderBits width of the marker borders.
+     *
+     * This function return the image of the ChArUco board, ready to be printed.
+     */
+    CV_WRAP void draw(Size outSize, OutputArray img, int marginSize = 0, int borderBits = 1);
+
+
+    /**
+     * @brief Create a CharucoBoard object
+     *
+     * @param squaresX number of chessboard squares in X direction
+     * @param squaresY number of chessboard squares in Y direction
+     * @param squareLength chessboard square side length (normally in meters)
+     * @param markerLength marker side length (same unit than squareLength)
+     * @param dictionary dictionary of markers indicating the type of markers.
+     * The first markers in the dictionary are used to fill the white chessboard squares.
+     * @return the output CharucoBoard object
+     *
+     * This functions creates a CharucoBoard object given the number of squares in each direction
+     * and the size of the markers and chessboard squares.
+     */
+    CV_WRAP static Ptr<CharucoBoard> create(int squaresX, int squaresY, float squareLength,
+                                            float markerLength, const Ptr<Dictionary> &dictionary);
+
+    /**
+      *
+      */
+    CV_WRAP Size getChessboardSize() const { return Size(_squaresX, _squaresY); }
+
+    /**
+      *
+      */
+    CV_WRAP float getSquareLength() const { return _squareLength; }
+
+    /**
+      *
+      */
+    CV_WRAP float getMarkerLength() const { return _markerLength; }
+
+    private:
+    void _getNearestMarkerCorners();
+
+    // number of markers in X and Y directions
+    int _squaresX, _squaresY;
+
+    // size of chessboard squares side (normally in meters)
+    float _squareLength;
+
+    // marker side lenght (normally in meters)
+    float _markerLength;
+};
+
+
+
+
+/**
+ * @brief Interpolate position of ChArUco board corners
+ * @param markerCorners vector of already detected markers corners. For each marker, its four
+ * corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the
+ * dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @param markerIds list of identifiers for each marker in corners
+ * @param image input image necesary for corner refinement. Note that markers are not detected and
+ * should be sent in corners and ids parameters.
+ * @param board layout of ChArUco board.
+ * @param charucoCorners interpolated chessboard corners
+ * @param charucoIds interpolated chessboard corners identifiers
+ * @param cameraMatrix optional 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs optional vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param minMarkers number of adjacent markers that must be detected to return a charuco corner
+ *
+ * This function receives the detected markers and returns the 2D position of the chessboard corners
+ * from a ChArUco board using the detected Aruco markers. If camera parameters are provided,
+ * the process is based in an approximated pose estimation, else it is based on local homography.
+ * Only visible corners are returned. For each corner, its corresponding identifier is
+ * also returned in charucoIds.
+ * The function returns the number of interpolated corners.
+ */
+CV_EXPORTS_W int interpolateCornersCharuco(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                           InputArray image, const Ptr<CharucoBoard> &board,
+                                           OutputArray charucoCorners, OutputArray charucoIds,
+                                           InputArray cameraMatrix = noArray(),
+                                           InputArray distCoeffs = noArray(), int minMarkers = 2);
+
+
+
+
+/**
+ * @brief Pose estimation for a ChArUco board given some of their corners
+ * @param charucoCorners vector of detected charuco corners
+ * @param charucoIds list of identifiers for each corner in charucoCorners
+ * @param board layout of ChArUco board.
+ * @param cameraMatrix input 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+ * @param distCoeffs vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvec Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board
+ * (see cv::Rodrigues).
+ * @param tvec Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.
+ * @param useExtrinsicGuess defines whether initial guess for \b rvec and \b tvec will be used or not.
+ *
+ * This function estimates a Charuco board pose from some detected corners.
+ * The function checks if the input corners are enough and valid to perform pose estimation.
+ * If pose estimation is valid, returns true, else returns false.
+ */
+CV_EXPORTS_W bool estimatePoseCharucoBoard(InputArray charucoCorners, InputArray charucoIds,
+                                           const Ptr<CharucoBoard> &board, InputArray cameraMatrix,
+                                           InputArray distCoeffs, OutputArray rvec, OutputArray tvec,
+                                           bool useExtrinsicGuess = false);
+
+
+
+
+/**
+ * @brief Draws a set of Charuco corners
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param charucoCorners vector of detected charuco corners
+ * @param charucoIds list of identifiers for each corner in charucoCorners
+ * @param cornerColor color of the square surrounding each corner
+ *
+ * This function draws a set of detected Charuco corners. If identifiers vector is provided, it also
+ * draws the id of each corner.
+ */
+CV_EXPORTS_W void drawDetectedCornersCharuco(InputOutputArray image, InputArray charucoCorners,
+                                             InputArray charucoIds = noArray(),
+                                             Scalar cornerColor = Scalar(255, 0, 0));
+
+
+
+/**
+ * @brief Calibrate a camera using Charuco corners
+ *
+ * @param charucoCorners vector of detected charuco corners per frame
+ * @param charucoIds list of identifiers for each corner in charucoCorners per frame
+ * @param board Marker Board layout
+ * @param imageSize input image size
+ * @param cameraMatrix Output 3x3 floating-point camera matrix
+ * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV\_CALIB\_USE\_INTRINSIC\_GUESS
+ * and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be
+ * initialized before calling the function.
+ * @param distCoeffs Output vector of distortion coefficients
+ * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+ * @param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each board view
+ * (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding
+ * k-th translation vector (see the next output parameter description) brings the board pattern
+ * from the model coordinate space (in which object points are specified) to the world coordinate
+ * space, that is, a real position of the board pattern in the k-th pattern view (k=0.. *M* -1).
+ * @param tvecs Output vector of translation vectors estimated for each pattern view.
+ * @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
+ * Order of deviations values:
+ * \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3,
+ * s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
+ * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
+ * Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views,
+ * \f$R_i, T_i\f$ are concatenated 1x3 vectors.
+ * @param perViewErrors Output vector of average re-projection errors estimated for each pattern view.
+ * @param flags flags Different flags  for the calibration process (see #calibrateCamera for details).
+ * @param criteria Termination criteria for the iterative optimization algorithm.
+ *
+ * This function calibrates a camera using a set of corners of a  Charuco Board. The function
+ * receives a list of detected corners and its identifiers from several views of the Board.
+ * The function returns the final re-projection error.
+ */
+CV_EXPORTS_AS(calibrateCameraCharucoExtended) double calibrateCameraCharuco(
+    InputArrayOfArrays charucoCorners, InputArrayOfArrays charucoIds, const Ptr<CharucoBoard> &board,
+    Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+    OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+    OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics,
+    OutputArray perViewErrors, int flags = 0,
+    TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
+
+/** @brief It's the same function as #calibrateCameraCharuco but without calibration error estimation.
+*/
+CV_EXPORTS_W double calibrateCameraCharuco(
+  InputArrayOfArrays charucoCorners, InputArrayOfArrays charucoIds, const Ptr<CharucoBoard> &board,
+  Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+  OutputArrayOfArrays rvecs = noArray(), OutputArrayOfArrays tvecs = noArray(), int flags = 0,
+  TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
+
+
+
+/**
+ * @brief Detect ChArUco Diamond markers
+ *
+ * @param image input image necessary for corner subpixel.
+ * @param markerCorners list of detected marker corners from detectMarkers function.
+ * @param markerIds list of marker ids in markerCorners.
+ * @param squareMarkerLengthRate rate between square and marker length:
+ * squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary.
+ * @param diamondCorners output list of detected diamond corners (4 corners per diamond). The order
+ * is the same than in marker corners: top left, top right, bottom right and bottom left. Similar
+ * format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).
+ * @param diamondIds ids of the diamonds in diamondCorners. The id of each diamond is in fact of
+ * type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the
+ * diamond.
+ * @param cameraMatrix Optional camera calibration matrix.
+ * @param distCoeffs Optional camera distortion coefficients.
+ *
+ * This function detects Diamond markers from the previous detected ArUco markers. The diamonds
+ * are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters
+ * are provided, the diamond search is based on reprojection. If not, diamond search is based on
+ * homography. Homography is faster than reprojection but can slightly reduce the detection rate.
+ */
+CV_EXPORTS_W void detectCharucoDiamond(InputArray image, InputArrayOfArrays markerCorners,
+                                       InputArray markerIds, float squareMarkerLengthRate,
+                                       OutputArrayOfArrays diamondCorners, OutputArray diamondIds,
+                                       InputArray cameraMatrix = noArray(),
+                                       InputArray distCoeffs = noArray());
+
+
+
+/**
+ * @brief Draw a set of detected ChArUco Diamond markers
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param diamondCorners positions of diamond corners in the same format returned by
+ * detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+ * the dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @param diamondIds vector of identifiers for diamonds in diamondCorners, in the same format
+ * returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>).
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one.
+ *
+ * Given an array of detected diamonds, this functions draws them in the image. The marker borders
+ * are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedDiamonds(InputOutputArray image, InputArrayOfArrays diamondCorners,
+                                       InputArray diamondIds = noArray(),
+                                       Scalar borderColor = Scalar(0, 0, 255));
+
+
+
+
+/**
+ * @brief Draw a ChArUco Diamond marker
+ *
+ * @param dictionary dictionary of markers indicating the type of markers.
+ * @param ids list of 4 ids for each ArUco marker in the ChArUco marker.
+ * @param squareLength size of the chessboard squares in pixels.
+ * @param markerLength size of the markers in pixels.
+ * @param img output image with the marker. The size of this image will be
+ * 3*squareLength + 2*marginSize,.
+ * @param marginSize minimum margins (in pixels) of the marker in the output image
+ * @param borderBits width of the marker borders.
+ *
+ * This function return the image of a ChArUco marker, ready to be printed.
+ */
+// TODO cannot be exported yet; conversion from/to Vec4i is not wrapped in core
+CV_EXPORTS void drawCharucoDiamond(const Ptr<Dictionary> &dictionary, Vec4i ids, int squareLength,
+                                   int markerLength, OutputArray img, int marginSize = 0,
+                                   int borderBits = 1);
+
+
+
+
+//! @}
+}
+}
+
+#endif

aruco_pose/vendor/aruco/include/opencv2/aruco/dictionary.hpp

@@ -0,0 +1,212 @@
+/*
+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
+ *
+ * bytesList contains the marker codewords where
+ * - bytesList.rows is the dictionary size
+ * - each marker is encoded using `nbytes = ceil(markerSize*markerSize/8.)`
+ * - each row contains all 4 rotations of the marker, so its length is `4*nbytes`
+ *
+ * `bytesList.ptr(i)[k*nbytes + j]` is then the j-th byte of i-th marker, in its k-th rotation.
+ */
+class CV_EXPORTS_W Dictionary {
+
+    public:
+    CV_PROP_RW Mat bytesList;         // marker code information
+    CV_PROP_RW int markerSize;        // number of bits per dimension
+    CV_PROP_RW int maxCorrectionBits; // maximum number of bits that can be corrected
+
+
+    /**
+      */
+    Dictionary(const Mat &_bytesList = Mat(), int _markerSize = 0, int _maxcorr = 0);
+
+
+    /**
+    Dictionary(const Dictionary &_dictionary);
+    */
+
+
+    /**
+      */
+    Dictionary(const Ptr<Dictionary> &_dictionary);
+
+
+    /**
+     * @see generateCustomDictionary
+     */
+    CV_WRAP_AS(create) static Ptr<Dictionary> create(int nMarkers, int markerSize, int randomSeed=0);
+
+
+    /**
+     * @see generateCustomDictionary
+     */
+    CV_WRAP_AS(create_from) static Ptr<Dictionary> create(int nMarkers, int markerSize,
+            const Ptr<Dictionary> &baseDictionary, int randomSeed=0);
+
+    /**
+     * @see getPredefinedDictionary
+     */
+    CV_WRAP static Ptr<Dictionary> get(int dict);
+
+    /**
+     * @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
+     */
+    CV_WRAP 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
+      */
+    CV_WRAP static Mat getByteListFromBits(const Mat &bits);
+
+
+    /**
+      * @brief Transform list of bytes to matrix of bits
+      */
+    CV_WRAP 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_ORIGINAL: 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,
+    DICT_APRILTAG_16h5,     ///< 4x4 bits, minimum hamming distance between any two codes = 5, 30 codes
+    DICT_APRILTAG_25h9,     ///< 5x5 bits, minimum hamming distance between any two codes = 9, 35 codes
+    DICT_APRILTAG_36h10,    ///< 6x6 bits, minimum hamming distance between any two codes = 10, 2320 codes
+    DICT_APRILTAG_36h11     ///< 6x6 bits, minimum hamming distance between any two codes = 11, 587 codes
+};
+
+
+/**
+  * @brief Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME
+  */
+CV_EXPORTS Ptr<Dictionary> getPredefinedDictionary(PREDEFINED_DICTIONARY_NAME name);
+
+
+/**
+  * @brief Returns one of the predefined dictionaries referenced by DICT_*.
+  */
+CV_EXPORTS_W Ptr<Dictionary> getPredefinedDictionary(int dict);
+
+
+/**
+  * @see generateCustomDictionary
+  */
+CV_EXPORTS_AS(custom_dictionary) Ptr<Dictionary> generateCustomDictionary(
+        int nMarkers,
+        int markerSize,
+        int randomSeed=0);
+
+
+/**
+  * @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)
+  * @param randomSeed a user supplied seed for theRNG()
+  *
+  * 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_AS(custom_dictionary_from) Ptr<Dictionary> generateCustomDictionary(
+        int nMarkers,
+        int markerSize,
+        const Ptr<Dictionary> &baseDictionary,
+        int randomSeed=0);
+
+
+
+//! @}
+}
+}
+
+#endif

aruco_pose/vendor/aruco/samples/calibrate_camera.cpp

@@ -0,0 +1,294 @@
+/*
+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/calib3d.hpp>
+#include <opencv2/aruco.hpp>
+#include <opencv2/imgproc.hpp>
+#include <vector>
+#include <iostream>
+#include <ctime>
+
+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}"
+        "{@outfile |<none> | 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 }";
+}
+
+/**
+ */
+static bool readDetectorParameters(string filename, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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;
+}
+
+
+
+/**
+ */
+static bool saveCameraParams(const string &filename, Size imageSize, float aspectRatio, int flags,
+                             const Mat &cameraMatrix, const Mat &distCoeffs, double totalAvgErr) {
+    FileStorage fs(filename, FileStorage::WRITE);
+    if(!fs.isOpened())
+        return false;
+
+    time_t tt;
+    time(&tt);
+    struct tm *t2 = localtime(&tt);
+    char buf[1024];
+    strftime(buf, sizeof(buf) - 1, "%c", t2);
+
+    fs << "calibration_time" << buf;
+
+    fs << "image_width" << imageSize.width;
+    fs << "image_height" << imageSize.height;
+
+    if(flags & CALIB_FIX_ASPECT_RATIO) fs << "aspectRatio" << aspectRatio;
+
+    if(flags != 0) {
+        sprintf(buf, "flags: %s%s%s%s",
+                flags & CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "",
+                flags & CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "",
+                flags & CALIB_FIX_PRINCIPAL_POINT ? "+fix_principal_point" : "",
+                flags & CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "");
+    }
+
+    fs << "flags" << flags;
+
+    fs << "camera_matrix" << cameraMatrix;
+    fs << "distortion_coefficients" << distCoeffs;
+
+    fs << "avg_reprojection_error" << totalAvgErr;
+
+    return true;
+}
+
+
+
+/**
+ */
+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");
+    int dictionaryId = parser.get<int>("d");
+    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;
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+
+    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;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    // create board object
+    Ptr<aruco::GridBoard> gridboard =
+            aruco::GridBoard::create(markersX, markersY, markerLength, markerSeparation, dictionary);
+    Ptr<aruco::Board> board = gridboard.staticCast<aruco::Board>();
+
+    // collected frames for calibration
+    vector< vector< vector< Point2f > > > allCorners;
+    vector< vector< int > > allIds;
+    Size imgSize;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        vector< int > ids;
+        vector< vector< Point2f > > corners, rejected;
+
+        // 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);
+
+        // draw results
+        image.copyTo(imageCopy);
+        if(ids.size() > 0) aruco::drawDetectedMarkers(imageCopy, corners, ids);
+        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);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+        if(key == 'c' && ids.size() > 0) {
+            cout << "Frame captured" << endl;
+            allCorners.push_back(corners);
+            allIds.push_back(ids);
+            imgSize = image.size();
+        }
+    }
+
+    if(allIds.size() < 1) {
+        cerr << "Not enough captures for calibration" << endl;
+        return 0;
+    }
+
+    Mat cameraMatrix, distCoeffs;
+    vector< Mat > rvecs, tvecs;
+    double repError;
+
+    if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
+        cameraMatrix = Mat::eye(3, 3, CV_64F);
+        cameraMatrix.at< double >(0, 0) = aspectRatio;
+    }
+
+    // prepare data for calibration
+    vector< vector< Point2f > > allCornersConcatenated;
+    vector< int > allIdsConcatenated;
+    vector< int > markerCounterPerFrame;
+    markerCounterPerFrame.reserve(allCorners.size());
+    for(unsigned int i = 0; i < allCorners.size(); i++) {
+        markerCounterPerFrame.push_back((int)allCorners[i].size());
+        for(unsigned int j = 0; j < allCorners[i].size(); j++) {
+            allCornersConcatenated.push_back(allCorners[i][j]);
+            allIdsConcatenated.push_back(allIds[i][j]);
+        }
+    }
+    // calibrate camera
+    repError = aruco::calibrateCameraAruco(allCornersConcatenated, allIdsConcatenated,
+                                           markerCounterPerFrame, board, imgSize, cameraMatrix,
+                                           distCoeffs, rvecs, tvecs, calibrationFlags);
+
+    bool saveOk = saveCameraParams(outputFile, imgSize, 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;
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/calibrate_camera_charuco.cpp

@@ -0,0 +1,358 @@
+/*
+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/calib3d.hpp>
+#include <opencv2/aruco/charuco.hpp>
+#include <opencv2/imgproc.hpp>
+#include <vector>
+#include <iostream>
+#include <ctime>
+
+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}"
+        "{@outfile |<none> | 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 }";
+}
+
+/**
+ */
+static bool readDetectorParameters(string filename, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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;
+}
+
+
+
+/**
+ */
+static bool saveCameraParams(const string &filename, Size imageSize, float aspectRatio, int flags,
+                             const Mat &cameraMatrix, const Mat &distCoeffs, double totalAvgErr) {
+    FileStorage fs(filename, FileStorage::WRITE);
+    if(!fs.isOpened())
+        return false;
+
+    time_t tt;
+    time(&tt);
+    struct tm *t2 = localtime(&tt);
+    char buf[1024];
+    strftime(buf, sizeof(buf) - 1, "%c", t2);
+
+    fs << "calibration_time" << buf;
+
+    fs << "image_width" << imageSize.width;
+    fs << "image_height" << imageSize.height;
+
+    if(flags & CALIB_FIX_ASPECT_RATIO) fs << "aspectRatio" << aspectRatio;
+
+    if(flags != 0) {
+        sprintf(buf, "flags: %s%s%s%s",
+                flags & CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "",
+                flags & CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "",
+                flags & CALIB_FIX_PRINCIPAL_POINT ? "+fix_principal_point" : "",
+                flags & CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "");
+    }
+
+    fs << "flags" << flags;
+
+    fs << "camera_matrix" << cameraMatrix;
+    fs << "distortion_coefficients" << distCoeffs;
+
+    fs << "avg_reprojection_error" << totalAvgErr;
+
+    return true;
+}
+
+
+
+/**
+ */
+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");
+    int dictionaryId = parser.get<int>("d");
+    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;
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+
+    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;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    // create charuco board object
+    Ptr<aruco::CharucoBoard> charucoboard =
+            aruco::CharucoBoard::create(squaresX, squaresY, squareLength, markerLength, dictionary);
+    Ptr<aruco::Board> board = charucoboard.staticCast<aruco::Board>();
+
+    // collect data from each frame
+    vector< vector< vector< Point2f > > > allCorners;
+    vector< vector< int > > allIds;
+    vector< Mat > allImgs;
+    Size imgSize;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        vector< int > ids;
+        vector< vector< Point2f > > corners, rejected;
+
+        // 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);
+
+        // interpolate charuco corners
+        Mat currentCharucoCorners, currentCharucoIds;
+        if(ids.size() > 0)
+            aruco::interpolateCornersCharuco(corners, ids, image, charucoboard, currentCharucoCorners,
+                                             currentCharucoIds);
+
+        // draw results
+        image.copyTo(imageCopy);
+        if(ids.size() > 0) aruco::drawDetectedMarkers(imageCopy, corners);
+
+        if(currentCharucoCorners.total() > 0)
+            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);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+        if(key == 'c' && ids.size() > 0) {
+            cout << "Frame captured" << endl;
+            allCorners.push_back(corners);
+            allIds.push_back(ids);
+            allImgs.push_back(image);
+            imgSize = image.size();
+        }
+    }
+
+    if(allIds.size() < 1) {
+        cerr << "Not enough captures for calibration" << endl;
+        return 0;
+    }
+
+    Mat cameraMatrix, distCoeffs;
+    vector< Mat > rvecs, tvecs;
+    double repError;
+
+    if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
+        cameraMatrix = Mat::eye(3, 3, CV_64F);
+        cameraMatrix.at< double >(0, 0) = aspectRatio;
+    }
+
+    // prepare data for calibration
+    vector< vector< Point2f > > allCornersConcatenated;
+    vector< int > allIdsConcatenated;
+    vector< int > markerCounterPerFrame;
+    markerCounterPerFrame.reserve(allCorners.size());
+    for(unsigned int i = 0; i < allCorners.size(); i++) {
+        markerCounterPerFrame.push_back((int)allCorners[i].size());
+        for(unsigned int j = 0; j < allCorners[i].size(); j++) {
+            allCornersConcatenated.push_back(allCorners[i][j]);
+            allIdsConcatenated.push_back(allIds[i][j]);
+        }
+    }
+
+    // calibrate camera using aruco markers
+    double arucoRepErr;
+    arucoRepErr = aruco::calibrateCameraAruco(allCornersConcatenated, allIdsConcatenated,
+                                              markerCounterPerFrame, board, imgSize, cameraMatrix,
+                                              distCoeffs, noArray(), noArray(), calibrationFlags);
+
+    // prepare data for charuco calibration
+    int nFrames = (int)allCorners.size();
+    vector< Mat > allCharucoCorners;
+    vector< Mat > allCharucoIds;
+    vector< Mat > filteredImages;
+    allCharucoCorners.reserve(nFrames);
+    allCharucoIds.reserve(nFrames);
+
+    for(int i = 0; i < nFrames; i++) {
+        // interpolate using camera parameters
+        Mat currentCharucoCorners, currentCharucoIds;
+        aruco::interpolateCornersCharuco(allCorners[i], allIds[i], allImgs[i], charucoboard,
+                                         currentCharucoCorners, currentCharucoIds, cameraMatrix,
+                                         distCoeffs);
+
+        allCharucoCorners.push_back(currentCharucoCorners);
+        allCharucoIds.push_back(currentCharucoIds);
+        filteredImages.push_back(allImgs[i]);
+    }
+
+    if(allCharucoCorners.size() < 4) {
+        cerr << "Not enough corners for calibration" << endl;
+        return 0;
+    }
+
+    // calibrate camera using charuco
+    repError =
+        aruco::calibrateCameraCharuco(allCharucoCorners, allCharucoIds, charucoboard, imgSize,
+                                      cameraMatrix, distCoeffs, rvecs, tvecs, calibrationFlags);
+
+    bool saveOk =  saveCameraParams(outputFile, imgSize, aspectRatio, calibrationFlags,
+                                    cameraMatrix, distCoeffs, repError);
+    if(!saveOk) {
+        cerr << "Cannot save output file" << endl;
+        return 0;
+    }
+
+    cout << "Rep Error: " << repError << endl;
+    cout << "Rep Error Aruco: " << arucoRepErr << endl;
+    cout << "Calibration saved to " << outputFile << endl;
+
+    // show interpolated charuco corners for debugging
+    if(showChessboardCorners) {
+        for(unsigned int frame = 0; frame < filteredImages.size(); frame++) {
+            Mat imageCopy = filteredImages[frame].clone();
+            if(allIds[frame].size() > 0) {
+
+                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;
+}

aruco_pose/vendor/aruco/samples/create_board.cpp

@@ -0,0 +1,114 @@
+/*
+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>
+
+using namespace cv;
+
+namespace {
+const char* about = "Create an ArUco grid board image";
+const char* keys  =
+        "{@outfile |<none> | Output image }"
+        "{w        |       | Number of markers in X direction }"
+        "{h        |       | Number of markers in Y direction }"
+        "{l        |       | Marker side length (in pixels) }"
+        "{s        |       | Separation between two consecutive markers in the grid (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}"
+        "{m        |       | Margins size (in pixels). Default is marker separation (-s) }"
+        "{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);
+
+    if(argc < 7) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int markersX = parser.get<int>("w");
+    int markersY = parser.get<int>("h");
+    int markerLength = parser.get<int>("l");
+    int markerSeparation = parser.get<int>("s");
+    int dictionaryId = parser.get<int>("d");
+    int margins = markerSeparation;
+    if(parser.has("m")) {
+        margins = parser.get<int>("m");
+    }
+
+    int borderBits = parser.get<int>("bb");
+    bool showImage = parser.get<bool>("si");
+
+    String out = parser.get<String>(0);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Size imageSize;
+    imageSize.width = markersX * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
+    imageSize.height =
+        markersY * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    Ptr<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(out, boardImage);
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/create_board_charuco.cpp

@@ -0,0 +1,113 @@
+/*
+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>
+
+using namespace cv;
+
+namespace {
+const char* about = "Create a ChArUco board image";
+const char* keys  =
+        "{@outfile |<none> | Output image }"
+        "{w        |       | Number of squares in X direction }"
+        "{h        |       | Number of squares in Y direction }"
+        "{sl       |       | Square side length (in pixels) }"
+        "{ml       |       | 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}"
+        "{m        |       | Margins size (in pixels). Default is (squareLength-markerLength) }"
+        "{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);
+
+    if(argc < 7) {
+        parser.printMessage();
+        return 0;
+    }
+
+    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 dictionaryId = parser.get<int>("d");
+    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");
+
+    String out = parser.get<String>(0);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    Size imageSize;
+    imageSize.width = squaresX * squareLength + 2 * margins;
+    imageSize.height = squaresY * squareLength + 2 * margins;
+
+    Ptr<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(out, boardImage);
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/create_diamond.cpp

@@ -0,0 +1,118 @@
+/*
+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;
+
+namespace {
+const char* about = "Create a ChArUco marker image";
+const char* keys  =
+        "{@outfile |<none> | Output image }"
+        "{sl       |       | Square side length (in pixels) }"
+        "{ml       |       | 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}"
+        "{ids      |<none> | 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);
+
+    if(argc < 4) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int squareLength = parser.get<int>("sl");
+    int markerLength = parser.get<int>("ml");
+    int dictionaryId = parser.get<int>("d");
+    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);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    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;
+        parser.printMessage();
+        return 0;
+    }
+    Vec4i ids;
+    for(int i = 0; i < 4; i++)
+        ids[i] = atoi(splittedIds[i].c_str());
+
+    Mat markerImg;
+    aruco::drawCharucoDiamond(dictionary, ids, squareLength, markerLength, markerImg, margins,
+                              borderBits);
+
+    if(showImage) {
+        imshow("board", markerImg);
+        waitKey(0);
+    }
+
+    imwrite(out, markerImg);
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/create_marker.cpp

@@ -0,0 +1,96 @@
+/*
+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>
+
+using namespace cv;
+
+namespace {
+const char* about = "Create an ArUco marker image";
+const char* keys  =
+        "{@outfile |<none> | Output image }"
+        "{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}"
+        "{id       |       | Marker id in the dictionary }"
+        "{ms       | 200   | Marker 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);
+
+    if(argc < 4) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int dictionaryId = parser.get<int>("d");
+    int markerId = parser.get<int>("id");
+    int borderBits = parser.get<int>("bb");
+    int markerSize = parser.get<int>("ms");
+    bool showImage = parser.get<bool>("si");
+
+    String out = parser.get<String>(0);
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    Mat markerImg;
+    aruco::drawMarker(dictionary, markerId, markerSize, markerImg, borderBits);
+
+    if(showImage) {
+        imshow("marker", markerImg);
+        waitKey(0);
+    }
+
+    imwrite(out, markerImg);
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/detect_board.cpp

@@ -0,0 +1,234 @@
+/*
+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;
+
+namespace {
+const char* about = "Pose estimation using a ArUco Planar Grid board";
+const char* keys  =
+        "{w        |       | Number of squares in X direction }"
+        "{h        |       | Number of squares in Y direction }"
+        "{l        |       | Marker side lenght (in pixels) }"
+        "{s        |       | Separation between two consecutive markers in the grid (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}"
+        "{c        |       | 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       |       | Apply refind strategy }"
+        "{r        |       | show rejected candidates too }";
+}
+
+/**
+ */
+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, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 7) {
+        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");
+    int dictionaryId = parser.get<int>("d");
+    bool showRejected = parser.has("r");
+    bool refindStrategy = parser.has("rs");
+    int camId = parser.get<int>("ci");
+
+
+    Mat camMatrix, distCoeffs;
+    if(parser.has("c")) {
+        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            return 0;
+        }
+    }
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+    detectorParams->cornerRefinementMethod = aruco::CORNER_REFINE_SUBPIX; // do corner refinement in markers
+
+    String video;
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(!video.empty()) {
+        inputVideo.open(video);
+        waitTime = 0;
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    float axisLength = 0.5f * ((float)min(markersX, markersY) * (markerLength + markerSeparation) +
+                               markerSeparation);
+
+    // create board object
+    Ptr<aruco::GridBoard> gridboard =
+        aruco::GridBoard::create(markersX, markersY, markerLength, markerSeparation, dictionary);
+    Ptr<aruco::Board> board = gridboard.staticCast<aruco::Board>();
+
+    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;
+        Vec3d 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;
+}

aruco_pose/vendor/aruco/samples/detect_board_charuco.cpp

@@ -0,0 +1,250 @@
+/*
+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;
+
+
+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}"
+        "{c        |       | 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       |       | Apply refind strategy }"
+        "{r        |       | show rejected candidates too }";
+}
+
+/**
+ */
+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, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 6) {
+        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");
+    int dictionaryId = parser.get<int>("d");
+    bool showRejected = parser.has("r");
+    bool refindStrategy = parser.has("rs");
+    int camId = parser.get<int>("ci");
+
+    String video;
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    Mat camMatrix, distCoeffs;
+    if(parser.has("c")) {
+        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            return 0;
+        }
+    }
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    VideoCapture inputVideo;
+    int waitTime;
+    if(!video.empty()) {
+        inputVideo.open(video);
+        waitTime = 0;
+    } else {
+        inputVideo.open(camId);
+        waitTime = 10;
+    }
+
+    float axisLength = 0.5f * ((float)min(squaresX, squaresY) * (squareLength));
+
+    // create charuco board object
+    Ptr<aruco::CharucoBoard> charucoboard =
+        aruco::CharucoBoard::create(squaresX, squaresY, squareLength, markerLength, dictionary);
+    Ptr<aruco::Board> board = charucoboard.staticCast<aruco::Board>();
+
+    double totalTime = 0;
+    int totalIterations = 0;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        vector< int > markerIds, charucoIds;
+        vector< vector< Point2f > > markerCorners, rejectedMarkers;
+        vector< Point2f > charucoCorners;
+        Vec3d rvec, tvec;
+
+        // detect markers
+        aruco::detectMarkers(image, dictionary, markerCorners, markerIds, detectorParams,
+                             rejectedMarkers);
+
+        // refind strategy to detect more markers
+        if(refindStrategy)
+            aruco::refineDetectedMarkers(image, board, markerCorners, markerIds, rejectedMarkers,
+                                         camMatrix, distCoeffs);
+
+        // interpolate charuco corners
+        int interpolatedCorners = 0;
+        if(markerIds.size() > 0)
+            interpolatedCorners =
+                aruco::interpolateCornersCharuco(markerCorners, markerIds, image, charucoboard,
+                                                 charucoCorners, charucoIds, camMatrix, distCoeffs);
+
+        // estimate charuco board pose
+        bool validPose = false;
+        if(camMatrix.total() != 0)
+            validPose = aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, charucoboard,
+                                                        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(markerIds.size() > 0) {
+            aruco::drawDetectedMarkers(imageCopy, markerCorners);
+        }
+
+        if(showRejected && rejectedMarkers.size() > 0)
+            aruco::drawDetectedMarkers(imageCopy, rejectedMarkers, noArray(), Scalar(100, 0, 255));
+
+        if(interpolatedCorners > 0) {
+            Scalar color;
+            color = Scalar(255, 0, 0);
+            aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, color);
+        }
+
+        if(validPose)
+            aruco::drawAxis(imageCopy, camMatrix, distCoeffs, rvec, tvec, axisLength);
+
+        imshow("out", imageCopy);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+    }
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/detect_diamonds.cpp

@@ -0,0 +1,252 @@
+/*
+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;
+
+
+namespace {
+const char* about = "Detect ChArUco markers";
+const char* keys  =
+        "{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}"
+        "{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 }"
+        "{rs       |       | Apply refind strategy }"
+        "{r        |       | show rejected candidates too }";
+}
+
+/**
+ */
+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, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 4) {
+        parser.printMessage();
+        return 0;
+    }
+
+    float squareLength = parser.get<float>("sl");
+    float markerLength = parser.get<float>("ml");
+    int dictionaryId = parser.get<int>("d");
+    bool showRejected = parser.has("r");
+    bool estimatePose = parser.has("c");
+    bool autoScale = parser.has("as");
+    float autoScaleFactor = autoScale ? parser.get<float>("as") : 1.f;
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+
+    int camId = parser.get<int>("ci");
+    String video;
+
+    if(parser.has("v")) {
+        video = parser.get<String>("v");
+    }
+
+    if(!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    Mat camMatrix, distCoeffs;
+    if(estimatePose) {
+        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            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;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        vector< int > markerIds;
+        vector< Vec4i > diamondIds;
+        vector< vector< Point2f > > markerCorners, rejectedMarkers, diamondCorners;
+        vector< Vec3d > rvecs, tvecs;
+
+        // detect markers
+        aruco::detectMarkers(image, dictionary, markerCorners, markerIds, detectorParams,
+                             rejectedMarkers);
+
+        // detect diamonds
+        if(markerIds.size() > 0)
+            aruco::detectCharucoDiamond(image, markerCorners, markerIds,
+                                        squareLength / markerLength, diamondCorners, diamondIds,
+                                        camMatrix, distCoeffs);
+
+        // estimate diamond pose
+        if(estimatePose && diamondIds.size() > 0) {
+            if(!autoScale) {
+                aruco::estimatePoseSingleMarkers(diamondCorners, squareLength, camMatrix,
+                                                 distCoeffs, rvecs, tvecs);
+            } else {
+                // if autoscale, extract square size from last diamond id
+                for(unsigned int i = 0; i < diamondCorners.size(); i++) {
+                    float autoSquareLength = autoScaleFactor * float(diamondIds[i].val[3]);
+                    vector< vector< Point2f > > currentCorners;
+                    vector< Vec3d > currentRvec, currentTvec;
+                    currentCorners.push_back(diamondCorners[i]);
+                    aruco::estimatePoseSingleMarkers(currentCorners, autoSquareLength, camMatrix,
+                                                     distCoeffs, currentRvec, currentTvec);
+                    rvecs.push_back(currentRvec[0]);
+                    tvecs.push_back(currentTvec[0]);
+                }
+            }
+        }
+
+
+        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(showRejected && rejectedMarkers.size() > 0)
+            aruco::drawDetectedMarkers(imageCopy, rejectedMarkers, noArray(), Scalar(100, 0, 255));
+
+        if(diamondIds.size() > 0) {
+            aruco::drawDetectedDiamonds(imageCopy, diamondCorners, diamondIds);
+
+            if(estimatePose) {
+                for(unsigned int i = 0; i < diamondIds.size(); i++)
+                    aruco::drawAxis(imageCopy, camMatrix, distCoeffs, rvecs[i], tvecs[i],
+                                    squareLength * 0.5f);
+            }
+        }
+
+        imshow("out", imageCopy);
+        char key = (char)waitKey(waitTime);
+        if(key == 27) break;
+    }
+
+    return 0;
+}

aruco_pose/vendor/aruco/samples/detect_markers.cpp

@@ -0,0 +1,222 @@
+/*
+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;
+
+namespace {
+const char* about = "Basic marker detection";
+const char* keys  =
+        "{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,"
+        "DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20}"
+        "{v        |       | Input from video file, if ommited, input comes from camera }"
+        "{ci       | 0     | Camera id if input doesnt come from video (-v) }"
+        "{c        |       | Camera intrinsic parameters. Needed for camera pose }"
+        "{l        | 0.1   | Marker side lenght (in meters). Needed for correct scale in camera pose }"
+        "{dp       |       | File of marker detector parameters }"
+        "{r        |       | show rejected candidates too }"
+        "{refine   |       | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"
+        "CORNER_REFINE_CONTOUR=2, CORNER_REFINE_APRILTAG=3}";
+}
+
+/**
+ */
+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, Ptr<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["cornerRefinementMethod"] >> params->cornerRefinementMethod;
+    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[]) {
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+
+    if(argc < 2) {
+        parser.printMessage();
+        return 0;
+    }
+
+    int dictionaryId = parser.get<int>("d");
+    bool showRejected = parser.has("r");
+    bool estimatePose = parser.has("c");
+    float markerLength = parser.get<float>("l");
+
+    Ptr<aruco::DetectorParameters> detectorParams = aruco::DetectorParameters::create();
+    if(parser.has("dp")) {
+        bool readOk = readDetectorParameters(parser.get<string>("dp"), detectorParams);
+        if(!readOk) {
+            cerr << "Invalid detector parameters file" << endl;
+            return 0;
+        }
+    }
+
+    if (parser.has("refine")) {
+        //override cornerRefinementMethod read from config file
+        detectorParams->cornerRefinementMethod = parser.get<int>("refine");
+    }
+    std::cout << "Corner refinement method (0: None, 1: Subpixel, 2:contour, 3: AprilTag 2): " << 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;
+    }
+
+    Ptr<aruco::Dictionary> dictionary =
+        aruco::getPredefinedDictionary(aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+    Mat camMatrix, distCoeffs;
+    if(estimatePose) {
+        bool readOk = readCameraParameters(parser.get<string>("c"), camMatrix, distCoeffs);
+        if(!readOk) {
+            cerr << "Invalid camera file" << endl;
+            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;
+
+    while(inputVideo.grab()) {
+        Mat image, imageCopy;
+        inputVideo.retrieve(image);
+
+        double tick = (double)getTickCount();
+
+        vector< int > ids;
+        vector< vector< Point2f > > corners, rejected;
+        vector< Vec3d > 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;
+}

aruco_pose/vendor/aruco/samples/detector_params.yml

@@ -0,0 +1,24 @@
+%YAML:1.0
+nmarkers: 1024
+adaptiveThreshWinSizeMin: 3
+adaptiveThreshWinSizeMax: 23
+adaptiveThreshWinSizeStep: 10
+adaptiveThreshWinSize: 21
+adaptiveThreshConstant: 7
+minMarkerPerimeterRate: 0.03
+maxMarkerPerimeterRate: 4.0
+polygonalApproxAccuracyRate: 0.05
+minCornerDistance: 10.0
+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

aruco_pose/vendor/aruco/src/apriltag_quad_thresh.hpp

@@ -0,0 +1,125 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+// limitation: image size must be <32768 in width and height. This is
+// because we use a fixed-point 16 bit integer representation with one
+// fractional bit.
+
+#ifndef _OPENCV_APRIL_QUAD_THRESH_HPP_
+#define _OPENCV_APRIL_QUAD_THRESH_HPP_
+
+#include "opencv2/aruco.hpp"
+#include "unionfind.hpp"
+#include "zmaxheap.hpp"
+#include "zarray.hpp"
+
+namespace cv {
+namespace aruco {
+
+static inline uint32_t u64hash_2(uint64_t x) {
+    return uint32_t((2654435761UL * x) >> 32);
+}
+
+struct uint64_zarray_entry{
+    uint64_t id;
+    zarray_t *cluster;
+
+    struct uint64_zarray_entry *next;
+};
+
+struct pt{
+    // Note: these represent 2*actual value.
+    uint16_t x, y;
+    float theta;
+    int16_t gx, gy;
+};
+
+struct remove_vertex{
+    int i;           // which vertex to remove?
+    int left, right; // left vertex, right vertex
+
+    double err;
+};
+
+struct segment{
+    int is_vertex;
+
+    // always greater than zero, but right can be > size, which denotes
+    // a wrap around back to the beginning of the points. and left < right.
+    int left, right;
+};
+
+struct line_fit_pt{
+    double Mx, My;
+    double Mxx, Myy, Mxy;
+    double W; // total weight
+};
+
+/**
+ * lfps contains *cumulative* moments for N points, with
+ * index j reflecting points [0,j] (inclusive).
+ * fit a line to the points [i0, i1] (inclusive). i0, i1 are both (0, sz)
+ * if i1 < i0, we treat this as a wrap around.
+ */
+void fit_line(struct line_fit_pt *lfps, int sz, int i0, int i1, double *lineparm, double *err, double *mse);
+
+int err_compare_descending(const void *_a, const void *_b);
+
+/**
+  1. Identify A) white points near a black point and B) black points near a white point.
+
+  2. Find the connected components within each of the classes above,
+  yielding clusters of "white-near-black" and
+  "black-near-white". (These two classes are kept separate). Each
+  segment has a unique id.
+
+  3. For every pair of "white-near-black" and "black-near-white"
+  clusters, find the set of points that are in one and adjacent to the
+  other. In other words, a "boundary" layer between the two
+  clusters. (This is actually performed by iterating over the pixels,
+  rather than pairs of clusters.) Critically, this helps keep nearby
+  edges from becoming connected.
+ **/
+int quad_segment_maxima(const Ptr<DetectorParameters> &td, int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ * returns 0 if the cluster looks bad.
+ */
+int quad_segment_agg(int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ *  return 1 if the quad looks okay, 0 if it should be discarded
+ *  quad
+ **/
+int fit_quad(const Ptr<DetectorParameters> &_params, const Mat im, zarray_t *cluster, struct sQuad *quad);
+
+/**
+ *
+ * @param mIm
+ * @param parameters
+ * @param mThresh
+ */
+void threshold(const Mat mIm, const Ptr<DetectorParameters> &parameters, Mat& mThresh);
+
+/**
+ *
+ * @param parameters
+ * @param mImg
+ * @param contours
+ * @return
+ */
+zarray_t *apriltag_quad_thresh(const Ptr<DetectorParameters> &parameters, const Mat & mImg, std::vector< std::vector< Point > > &contours);
+
+}}
+#endif

aruco_pose/vendor/aruco/src/charuco.cpp

@@ -0,0 +1,934 @@
+/*
+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 "precomp.hpp"
+#include "opencv2/aruco/charuco.hpp"
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+
+
+/**
+ */
+void CharucoBoard::draw(Size outSize, OutputArray _img, int marginSize, int borderBits) {
+
+    /* NOTE: OpenCV v<3.3 does not have .empty() as a Size member */
+    CV_Assert(outSize.height > 0 && outSize.width > 0);
+    CV_Assert(marginSize >= 0);
+
+    _img.create(outSize, CV_8UC1);
+    _img.setTo(255);
+    Mat out = _img.getMat();
+    Mat noMarginsImg =
+        out.colRange(marginSize, out.cols - marginSize).rowRange(marginSize, out.rows - marginSize);
+
+    double totalLengthX, totalLengthY;
+    totalLengthX = _squareLength * _squaresX;
+    totalLengthY = _squareLength * _squaresY;
+
+    // proportional transformation
+    double xReduction = totalLengthX / double(noMarginsImg.cols);
+    double yReduction = totalLengthY / double(noMarginsImg.rows);
+
+    // determine the zone where the chessboard is placed
+    Mat chessboardZoneImg;
+    if(xReduction > yReduction) {
+        int nRows = int(totalLengthY / xReduction);
+        int rowsMargins = (noMarginsImg.rows - nRows) / 2;
+        chessboardZoneImg = noMarginsImg.rowRange(rowsMargins, noMarginsImg.rows - rowsMargins);
+    } else {
+        int nCols = int(totalLengthX / yReduction);
+        int colsMargins = (noMarginsImg.cols - nCols) / 2;
+        chessboardZoneImg = noMarginsImg.colRange(colsMargins, noMarginsImg.cols - colsMargins);
+    }
+
+    // determine the margins to draw only the markers
+    // take the minimum just to be sure
+    double squareSizePixels = min(double(chessboardZoneImg.cols) / double(_squaresX),
+                                  double(chessboardZoneImg.rows) / double(_squaresY));
+
+    double diffSquareMarkerLength = (_squareLength - _markerLength) / 2;
+    int diffSquareMarkerLengthPixels =
+        int(diffSquareMarkerLength * squareSizePixels / _squareLength);
+
+    // draw markers
+    Mat markersImg;
+    aruco::_drawPlanarBoardImpl(this, chessboardZoneImg.size(), markersImg,
+                                diffSquareMarkerLengthPixels, borderBits);
+
+    markersImg.copyTo(chessboardZoneImg);
+
+    // now draw black squares
+    for(int y = 0; y < _squaresY; y++) {
+        for(int x = 0; x < _squaresX; x++) {
+
+            if(y % 2 != x % 2) continue; // white corner, dont do anything
+
+            double startX, startY;
+            startX = squareSizePixels * double(x);
+            startY = double(chessboardZoneImg.rows) - squareSizePixels * double(y + 1);
+
+            Mat squareZone = chessboardZoneImg.rowRange(int(startY), int(startY + squareSizePixels))
+                                 .colRange(int(startX), int(startX + squareSizePixels));
+
+            squareZone.setTo(0);
+        }
+    }
+}
+
+
+
+/**
+ */
+Ptr<CharucoBoard> CharucoBoard::create(int squaresX, int squaresY, float squareLength,
+                                  float markerLength, const Ptr<Dictionary> &dictionary) {
+
+    CV_Assert(squaresX > 1 && squaresY > 1 && markerLength > 0 && squareLength > markerLength);
+    Ptr<CharucoBoard> res = makePtr<CharucoBoard>();
+
+    res->_squaresX = squaresX;
+    res->_squaresY = squaresY;
+    res->_squareLength = squareLength;
+    res->_markerLength = markerLength;
+    res->dictionary = dictionary;
+
+    float diffSquareMarkerLength = (squareLength - markerLength) / 2;
+
+    // calculate Board objPoints
+    for(int y = squaresY - 1; y >= 0; y--) {
+        for(int x = 0; x < squaresX; x++) {
+
+            if(y % 2 == x % 2) continue; // black corner, no marker here
+
+            vector< Point3f > corners;
+            corners.resize(4);
+            corners[0] = Point3f(x * squareLength + diffSquareMarkerLength,
+                                 y * squareLength + diffSquareMarkerLength + markerLength, 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, -markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, -markerLength, 0);
+            res->objPoints.push_back(corners);
+            // first ids in dictionary
+            int nextId = (int)res->ids.size();
+            res->ids.push_back(nextId);
+        }
+    }
+
+    // now fill chessboardCorners
+    for(int y = 0; y < squaresY - 1; y++) {
+        for(int x = 0; x < squaresX - 1; x++) {
+            Point3f corner;
+            corner.x = (x + 1) * squareLength;
+            corner.y = (y + 1) * squareLength;
+            corner.z = 0;
+            res->chessboardCorners.push_back(corner);
+        }
+    }
+
+    res->_getNearestMarkerCorners();
+
+    return res;
+}
+
+
+
+/**
+  * Fill nearestMarkerIdx and nearestMarkerCorners arrays
+  */
+void CharucoBoard::_getNearestMarkerCorners() {
+
+    nearestMarkerIdx.resize(chessboardCorners.size());
+    nearestMarkerCorners.resize(chessboardCorners.size());
+
+    unsigned int nMarkers = (unsigned int)ids.size();
+    unsigned int nCharucoCorners = (unsigned int)chessboardCorners.size();
+    for(unsigned int i = 0; i < nCharucoCorners; i++) {
+        double minDist = -1; // distance of closest markers
+        Point3f charucoCorner = chessboardCorners[i];
+        for(unsigned int j = 0; j < nMarkers; j++) {
+            // calculate distance from marker center to charuco corner
+            Point3f center = Point3f(0, 0, 0);
+            for(unsigned int k = 0; k < 4; k++)
+                center += objPoints[j][k];
+            center /= 4.;
+            double sqDistance;
+            Point3f distVector = charucoCorner - center;
+            sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+            if(j == 0 || fabs(sqDistance - minDist) < cv::pow(0.01 * _squareLength, 2)) {
+                // if same minimum distance (or first iteration), add to nearestMarkerIdx vector
+                nearestMarkerIdx[i].push_back(j);
+                minDist = sqDistance;
+            } else if(sqDistance < minDist) {
+                // if finding a closest marker to the charuco corner
+                nearestMarkerIdx[i].clear(); // remove any previous added marker
+                nearestMarkerIdx[i].push_back(j); // add the new closest marker index
+                minDist = sqDistance;
+            }
+        }
+
+        // for each of the closest markers, search the marker corner index closer
+        // to the charuco corner
+        for(unsigned int j = 0; j < nearestMarkerIdx[i].size(); j++) {
+            nearestMarkerCorners[i].resize(nearestMarkerIdx[i].size());
+            double minDistCorner = -1;
+            for(unsigned int k = 0; k < 4; k++) {
+                double sqDistance;
+                Point3f distVector = charucoCorner - objPoints[nearestMarkerIdx[i][j]][k];
+                sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+                if(k == 0 || sqDistance < minDistCorner) {
+                    // if this corner is closer to the charuco corner, assing its index
+                    // to nearestMarkerCorners
+                    minDistCorner = sqDistance;
+                    nearestMarkerCorners[i][j] = k;
+                }
+            }
+        }
+    }
+}
+
+
+/**
+  * Remove charuco corners if any of their minMarkers closest markers has not been detected
+  */
+static int _filterCornersWithoutMinMarkers(const Ptr<CharucoBoard> &_board,
+                                                    InputArray _allCharucoCorners,
+                                                    InputArray _allCharucoIds,
+                                                    InputArray _allArucoIds, int minMarkers,
+                                                    OutputArray _filteredCharucoCorners,
+                                                    OutputArray _filteredCharucoIds) {
+
+    CV_Assert(minMarkers >= 0 && minMarkers <= 2);
+
+    vector< Point2f > filteredCharucoCorners;
+    vector< int > filteredCharucoIds;
+    // for each charuco corner
+    for(unsigned int i = 0; i < _allCharucoIds.getMat().total(); i++) {
+        int currentCharucoId = _allCharucoIds.getMat().at< int >(i);
+        int totalMarkers = 0; // nomber of closest marker detected
+        // look for closest markers
+        for(unsigned int m = 0; m < _board->nearestMarkerIdx[currentCharucoId].size(); m++) {
+            int markerId = _board->ids[_board->nearestMarkerIdx[currentCharucoId][m]];
+            bool found = false;
+            for(unsigned int k = 0; k < _allArucoIds.getMat().total(); k++) {
+                if(_allArucoIds.getMat().at< int >(k) == markerId) {
+                    found = true;
+                    break;
+                }
+            }
+            if(found) totalMarkers++;
+        }
+        // if enough markers detected, add the charuco corner to the final list
+        if(totalMarkers >= minMarkers) {
+            filteredCharucoIds.push_back(currentCharucoId);
+            filteredCharucoCorners.push_back(_allCharucoCorners.getMat().at< Point2f >(i));
+        }
+    }
+
+    // parse output
+    Mat(filteredCharucoCorners).copyTo(_filteredCharucoCorners);
+    Mat(filteredCharucoIds).copyTo(_filteredCharucoIds);
+    return (int)_filteredCharucoIds.total();
+}
+
+
+/**
+  * ParallelLoopBody class for the parallelization of the charuco corners subpixel refinement
+  * Called from function _selectAndRefineChessboardCorners()
+  */
+class CharucoSubpixelParallel : public ParallelLoopBody {
+    public:
+    CharucoSubpixelParallel(const Mat *_grey, vector< Point2f > *_filteredChessboardImgPoints,
+                            vector< Size > *_filteredWinSizes, const Ptr<DetectorParameters> &_params)
+        : grey(_grey), filteredChessboardImgPoints(_filteredChessboardImgPoints),
+          filteredWinSizes(_filteredWinSizes), params(_params) {}
+
+    void operator()(const Range &range) const CV_OVERRIDE {
+        const int begin = range.start;
+        const int end = range.end;
+
+        for(int i = begin; i < end; i++) {
+            vector< Point2f > in;
+            in.push_back((*filteredChessboardImgPoints)[i]);
+            Size winSize = (*filteredWinSizes)[i];
+            if(winSize.height == -1 || winSize.width == -1)
+                winSize = Size(params->cornerRefinementWinSize, params->cornerRefinementWinSize);
+
+            cornerSubPix(*grey, in, winSize, Size(),
+                         TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                      params->cornerRefinementMaxIterations,
+                                      params->cornerRefinementMinAccuracy));
+
+            (*filteredChessboardImgPoints)[i] = in[0];
+        }
+    }
+
+    private:
+    CharucoSubpixelParallel &operator=(const CharucoSubpixelParallel &); // to quiet MSVC
+
+    const Mat *grey;
+    vector< Point2f > *filteredChessboardImgPoints;
+    vector< Size > *filteredWinSizes;
+    const Ptr<DetectorParameters> &params;
+};
+
+
+
+
+/**
+  * @brief From all projected chessboard corners, select those inside the image and apply subpixel
+  * refinement. Returns number of valid corners.
+  */
+static int _selectAndRefineChessboardCorners(InputArray _allCorners, InputArray _image,
+                                                      OutputArray _selectedCorners,
+                                                      OutputArray _selectedIds,
+                                                      const vector< Size > &winSizes) {
+
+    const int minDistToBorder = 2; // minimum distance of the corner to the image border
+    // remaining corners, ids and window refinement sizes after removing corners outside the image
+    vector< Point2f > filteredChessboardImgPoints;
+    vector< Size > filteredWinSizes;
+    vector< int > filteredIds;
+
+    // filter corners outside the image
+    Rect innerRect(minDistToBorder, minDistToBorder, _image.getMat().cols - 2 * minDistToBorder,
+                   _image.getMat().rows - 2 * minDistToBorder);
+    for(unsigned int i = 0; i < _allCorners.getMat().total(); i++) {
+        if(innerRect.contains(_allCorners.getMat().at< Point2f >(i))) {
+            filteredChessboardImgPoints.push_back(_allCorners.getMat().at< Point2f >(i));
+            filteredIds.push_back(i);
+            filteredWinSizes.push_back(winSizes[i]);
+        }
+    }
+
+    // if none valid, return 0
+    if(filteredChessboardImgPoints.size() == 0) return 0;
+
+    // corner refinement, first convert input image to grey
+    Mat grey;
+    if(_image.type() == CV_8UC3)
+        cvtColor(_image, grey, COLOR_BGR2GRAY);
+    else
+        _image.copyTo(grey);
+
+    const Ptr<DetectorParameters> params = DetectorParameters::create(); // use default params for corner refinement
+
+    //// For each of the charuco corners, apply subpixel refinement using its correspondind winSize
+    // for(unsigned int i=0; i<filteredChessboardImgPoints.size(); i++) {
+    //    vector<Point2f> in;
+    //    in.push_back(filteredChessboardImgPoints[i]);
+    //    Size winSize = filteredWinSizes[i];
+    //    if(winSize.height == -1 || winSize.width == -1)
+    //        winSize = Size(params.cornerRefinementWinSize, params.cornerRefinementWinSize);
+    //    cornerSubPix(grey, in, winSize, Size(),
+    //                 TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+    //                              params->cornerRefinementMaxIterations,
+    //                              params->cornerRefinementMinAccuracy));
+    //    filteredChessboardImgPoints[i] = in[0];
+    //}
+
+    // this is the parallel call for the previous commented loop (result is equivalent)
+    parallel_for_(
+        Range(0, (int)filteredChessboardImgPoints.size()),
+        CharucoSubpixelParallel(&grey, &filteredChessboardImgPoints, &filteredWinSizes, params));
+
+    // parse output
+    Mat(filteredChessboardImgPoints).copyTo(_selectedCorners);
+    Mat(filteredIds).copyTo(_selectedIds);
+    return (int)filteredChessboardImgPoints.size();
+}
+
+
+/**
+  * Calculate the maximum window sizes for corner refinement for each charuco corner based on the
+  * distance to their closest markers
+  */
+static void _getMaximumSubPixWindowSizes(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                         InputArray charucoCorners, const Ptr<CharucoBoard> &board,
+                                         vector< Size > &sizes) {
+
+    unsigned int nCharucoCorners = (unsigned int)charucoCorners.getMat().total();
+    sizes.resize(nCharucoCorners, Size(-1, -1));
+
+    for(unsigned int i = 0; i < nCharucoCorners; i++) {
+        if(charucoCorners.getMat().at< Point2f >(i) == Point2f(-1, -1)) continue;
+        if(board->nearestMarkerIdx[i].size() == 0) continue;
+
+        double minDist = -1;
+        int counter = 0;
+
+        // calculate the distance to each of the closest corner of each closest marker
+        for(unsigned int j = 0; j < board->nearestMarkerIdx[i].size(); j++) {
+            // find marker
+            int markerId = board->ids[board->nearestMarkerIdx[i][j]];
+            int markerIdx = -1;
+            for(unsigned int k = 0; k < markerIds.getMat().total(); k++) {
+                if(markerIds.getMat().at< int >(k) == markerId) {
+                    markerIdx = k;
+                    break;
+                }
+            }
+            if(markerIdx == -1) continue;
+            Point2f markerCorner =
+                markerCorners.getMat(markerIdx).at< Point2f >(board->nearestMarkerCorners[i][j]);
+            Point2f charucoCorner = charucoCorners.getMat().at< Point2f >(i);
+            double dist = norm(markerCorner - charucoCorner);
+            if(minDist == -1) minDist = dist; // if first distance, just assign it
+            minDist = min(dist, minDist);
+            counter++;
+        }
+
+        // if this is the first closest marker, dont do anything
+        if(counter == 0)
+            continue;
+        else {
+            // else, calculate the maximum window size
+            int winSizeInt = int(minDist - 2); // remove 2 pixels for safety
+            if(winSizeInt < 1) winSizeInt = 1; // minimum size is 1
+            if(winSizeInt > 10) winSizeInt = 10; // maximum size is 10
+            sizes[i] = Size(winSizeInt, winSizeInt);
+        }
+    }
+}
+
+
+
+/**
+  * Interpolate charuco corners using approximated pose estimation
+  */
+static int _interpolateCornersCharucoApproxCalib(InputArrayOfArrays _markerCorners,
+                                                 InputArray _markerIds, InputArray _image,
+                                                 const Ptr<CharucoBoard> &_board,
+                                                 InputArray _cameraMatrix, InputArray _distCoeffs,
+                                                 OutputArray _charucoCorners,
+                                                 OutputArray _charucoIds) {
+
+    CV_Assert(_image.getMat().channels() == 1 || _image.getMat().channels() == 3);
+    CV_Assert(_markerCorners.total() == _markerIds.getMat().total() &&
+              _markerIds.getMat().total() > 0);
+
+    // approximated pose estimation using marker corners
+    Mat approximatedRvec, approximatedTvec;
+    int detectedBoardMarkers;
+    Ptr<Board> _b = _board.staticCast<Board>();
+    detectedBoardMarkers =
+        aruco::estimatePoseBoard(_markerCorners, _markerIds, _b,
+                                 _cameraMatrix, _distCoeffs, approximatedRvec, approximatedTvec);
+
+    if(detectedBoardMarkers == 0) return 0;
+
+    // project chessboard corners
+    vector< Point2f > allChessboardImgPoints;
+
+    projectPoints(_board->chessboardCorners, approximatedRvec, approximatedTvec, _cameraMatrix,
+                  _distCoeffs, allChessboardImgPoints);
+
+
+    // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+    // to the closes marker corner to avoid erroneous displacements to marker corners
+    vector< Size > subPixWinSizes;
+    _getMaximumSubPixWindowSizes(_markerCorners, _markerIds, allChessboardImgPoints, _board,
+                                 subPixWinSizes);
+
+    // filter corners outside the image and subpixel-refine charuco corners
+    return _selectAndRefineChessboardCorners(allChessboardImgPoints, _image, _charucoCorners,
+                                             _charucoIds, subPixWinSizes);
+}
+
+
+
+/**
+  * Interpolate charuco corners using local homography
+  */
+static int _interpolateCornersCharucoLocalHom(InputArrayOfArrays _markerCorners,
+                                              InputArray _markerIds, InputArray _image,
+                                              const Ptr<CharucoBoard> &_board,
+                                              OutputArray _charucoCorners,
+                                              OutputArray _charucoIds) {
+
+    CV_Assert(_image.getMat().channels() == 1 || _image.getMat().channels() == 3);
+    CV_Assert(_markerCorners.total() == _markerIds.getMat().total() &&
+              _markerIds.getMat().total() > 0);
+
+    unsigned int nMarkers = (unsigned int)_markerIds.getMat().total();
+
+    // calculate local homographies for each marker
+    vector< Mat > transformations;
+    transformations.resize(nMarkers);
+    for(unsigned int i = 0; i < nMarkers; i++) {
+        vector< Point2f > markerObjPoints2D;
+        int markerId = _markerIds.getMat().at< int >(i);
+        vector< int >::const_iterator it = find(_board->ids.begin(), _board->ids.end(), markerId);
+        if(it == _board->ids.end()) continue;
+        int boardIdx = (int)std::distance<std::vector<int>::const_iterator>(_board->ids.begin(), it);
+        markerObjPoints2D.resize(4);
+        for(unsigned int j = 0; j < 4; j++)
+            markerObjPoints2D[j] =
+                Point2f(_board->objPoints[boardIdx][j].x, _board->objPoints[boardIdx][j].y);
+
+        transformations[i] = getPerspectiveTransform(markerObjPoints2D, _markerCorners.getMat(i));
+    }
+
+    unsigned int nCharucoCorners = (unsigned int)_board->chessboardCorners.size();
+    vector< Point2f > allChessboardImgPoints(nCharucoCorners, Point2f(-1, -1));
+
+    // for each charuco corner, calculate its interpolation position based on the closest markers
+    // homographies
+    for(unsigned int i = 0; i < nCharucoCorners; i++) {
+        Point2f objPoint2D = Point2f(_board->chessboardCorners[i].x, _board->chessboardCorners[i].y);
+
+        vector< Point2f > interpolatedPositions;
+        for(unsigned int j = 0; j < _board->nearestMarkerIdx[i].size(); j++) {
+            int markerId = _board->ids[_board->nearestMarkerIdx[i][j]];
+            int markerIdx = -1;
+            for(unsigned int k = 0; k < _markerIds.getMat().total(); k++) {
+                if(_markerIds.getMat().at< int >(k) == markerId) {
+                    markerIdx = k;
+                    break;
+                }
+            }
+            if(markerIdx != -1) {
+                vector< Point2f > in, out;
+                in.push_back(objPoint2D);
+                perspectiveTransform(in, out, transformations[markerIdx]);
+                interpolatedPositions.push_back(out[0]);
+            }
+        }
+
+        // none of the closest markers detected
+        if(interpolatedPositions.size() == 0) continue;
+
+        // more than one closest marker detected, take middle point
+        if(interpolatedPositions.size() > 1) {
+            allChessboardImgPoints[i] = (interpolatedPositions[0] + interpolatedPositions[1]) / 2.;
+        }
+        // a single closest marker detected
+        else allChessboardImgPoints[i] = interpolatedPositions[0];
+    }
+
+    // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+    // to the closes marker corner to avoid erroneous displacements to marker corners
+    vector< Size > subPixWinSizes;
+    _getMaximumSubPixWindowSizes(_markerCorners, _markerIds, allChessboardImgPoints, _board,
+                                 subPixWinSizes);
+
+
+    // filter corners outside the image and subpixel-refine charuco corners
+    return _selectAndRefineChessboardCorners(allChessboardImgPoints, _image, _charucoCorners,
+                                             _charucoIds, subPixWinSizes);
+}
+
+
+
+/**
+  */
+int interpolateCornersCharuco(InputArrayOfArrays _markerCorners, InputArray _markerIds,
+                              InputArray _image, const Ptr<CharucoBoard> &_board,
+                              OutputArray _charucoCorners, OutputArray _charucoIds,
+                              InputArray _cameraMatrix, InputArray _distCoeffs, int minMarkers) {
+
+    // if camera parameters are avaible, use approximated calibration
+    if(_cameraMatrix.total() != 0) {
+        _interpolateCornersCharucoApproxCalib(_markerCorners, _markerIds, _image, _board,
+                                                     _cameraMatrix, _distCoeffs, _charucoCorners,
+                                                     _charucoIds);
+    }
+    // else use local homography
+    else {
+        _interpolateCornersCharucoLocalHom(_markerCorners, _markerIds, _image, _board,
+                                                  _charucoCorners, _charucoIds);
+    }
+
+    // to return a charuco corner, its closest aruco markers should have been detected
+    return _filterCornersWithoutMinMarkers(_board, _charucoCorners, _charucoIds, _markerIds,
+                                           minMarkers, _charucoCorners, _charucoIds);
+}
+
+
+
+/**
+  */
+void drawDetectedCornersCharuco(InputOutputArray _image, InputArray _charucoCorners,
+                                InputArray _charucoIds, Scalar cornerColor) {
+
+    CV_Assert(_image.getMat().total() != 0 &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_charucoCorners.getMat().total() == _charucoIds.getMat().total()) ||
+              _charucoIds.getMat().total() == 0);
+
+    unsigned int nCorners = (unsigned int)_charucoCorners.getMat().total();
+    for(unsigned int i = 0; i < nCorners; i++) {
+        Point2f corner = _charucoCorners.getMat().at< Point2f >(i);
+
+        // draw first corner mark
+        rectangle(_image, corner - Point2f(3, 3), corner + Point2f(3, 3), cornerColor, 1, LINE_AA);
+
+        // draw ID
+        if(_charucoIds.total() != 0) {
+            int id = _charucoIds.getMat().at< int >(i);
+            stringstream s;
+            s << "id=" << id;
+            putText(_image, s.str(), corner + Point2f(5, -5), FONT_HERSHEY_SIMPLEX, 0.5,
+                    cornerColor, 2);
+        }
+    }
+}
+
+
+/**
+  * Check if a set of 3d points are enough for calibration. Z coordinate is ignored.
+  * Only axis paralel lines are considered
+  */
+static bool _arePointsEnoughForPoseEstimation(const vector< Point3f > &points) {
+
+    if(points.size() < 4) return false;
+
+    vector< double > sameXValue; // different x values in points
+    vector< int > sameXCounter;  // number of points with the x value in sameXValue
+    for(unsigned int i = 0; i < points.size(); i++) {
+        bool found = false;
+        for(unsigned int j = 0; j < sameXValue.size(); j++) {
+            if(sameXValue[j] == points[i].x) {
+                found = true;
+                sameXCounter[j]++;
+            }
+        }
+        if(!found) {
+            sameXValue.push_back(points[i].x);
+            sameXCounter.push_back(1);
+        }
+    }
+
+    // count how many x values has more than 2 points
+    int moreThan2 = 0;
+    for(unsigned int i = 0; i < sameXCounter.size(); i++) {
+        if(sameXCounter[i] >= 2) moreThan2++;
+    }
+
+    // if we have more than 1 two xvalues with more than 2 points, calibration is ok
+    if(moreThan2 > 1)
+        return true;
+    else
+        return false;
+}
+
+
+/**
+  */
+bool estimatePoseCharucoBoard(InputArray _charucoCorners, InputArray _charucoIds,
+                              const Ptr<CharucoBoard> &_board, InputArray _cameraMatrix, InputArray _distCoeffs,
+                              OutputArray _rvec, OutputArray _tvec, bool useExtrinsicGuess) {
+
+    CV_Assert((_charucoCorners.getMat().total() == _charucoIds.getMat().total()));
+
+    // need, at least, 4 corners
+    if(_charucoIds.getMat().total() < 4) return false;
+
+    vector< Point3f > objPoints;
+    objPoints.reserve(_charucoIds.getMat().total());
+    for(unsigned int i = 0; i < _charucoIds.getMat().total(); i++) {
+        int currId = _charucoIds.getMat().at< int >(i);
+        CV_Assert(currId >= 0 && currId < (int)_board->chessboardCorners.size());
+        objPoints.push_back(_board->chessboardCorners[currId]);
+    }
+
+    // points need to be in different lines, check if detected points are enough
+    if(!_arePointsEnoughForPoseEstimation(objPoints)) return false;
+
+    solvePnP(objPoints, _charucoCorners, _cameraMatrix, _distCoeffs, _rvec, _tvec, useExtrinsicGuess);
+
+    return true;
+}
+
+
+
+
+/**
+  */
+double calibrateCameraCharuco(InputArrayOfArrays _charucoCorners, InputArrayOfArrays _charucoIds,
+                              const Ptr<CharucoBoard> &_board, Size imageSize,
+                              InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs,
+                              OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                              OutputArray _stdDeviationsIntrinsics,
+                              OutputArray _stdDeviationsExtrinsics,
+                              OutputArray _perViewErrors,
+                              int flags, TermCriteria criteria) {
+
+    CV_Assert(_charucoIds.total() > 0 && (_charucoIds.total() == _charucoCorners.total()));
+
+    // Join object points of charuco corners in a single vector for calibrateCamera() function
+    vector< vector< Point3f > > allObjPoints;
+    allObjPoints.resize(_charucoIds.total());
+    for(unsigned int i = 0; i < _charucoIds.total(); i++) {
+        unsigned int nCorners = (unsigned int)_charucoIds.getMat(i).total();
+        CV_Assert(nCorners > 0 && nCorners == _charucoCorners.getMat(i).total());
+        allObjPoints[i].reserve(nCorners);
+
+        for(unsigned int j = 0; j < nCorners; j++) {
+            int pointId = _charucoIds.getMat(i).at< int >(j);
+            CV_Assert(pointId >= 0 && pointId < (int)_board->chessboardCorners.size());
+            allObjPoints[i].push_back(_board->chessboardCorners[pointId]);
+        }
+    }
+
+    return calibrateCamera(allObjPoints, _charucoCorners, imageSize, _cameraMatrix, _distCoeffs,
+                           _rvecs, _tvecs, _stdDeviationsIntrinsics, _stdDeviationsExtrinsics,
+                           _perViewErrors, flags, criteria);
+}
+
+
+
+/**
+ */
+double calibrateCameraCharuco(InputArrayOfArrays _charucoCorners, InputArrayOfArrays _charucoIds,
+  const Ptr<CharucoBoard> &_board, Size imageSize,
+  InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs,
+  OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags,
+  TermCriteria criteria) {
+    return calibrateCameraCharuco(_charucoCorners, _charucoIds, _board, imageSize, _cameraMatrix, _distCoeffs, _rvecs,
+      _tvecs, noArray(), noArray(), noArray(), flags, criteria);
+}
+
+
+/**
+ */
+void detectCharucoDiamond(InputArray _image, InputArrayOfArrays _markerCorners,
+                          InputArray _markerIds, float squareMarkerLengthRate,
+                          OutputArrayOfArrays _diamondCorners, OutputArray _diamondIds,
+                          InputArray _cameraMatrix, InputArray _distCoeffs) {
+
+    CV_Assert(_markerIds.total() > 0 && _markerIds.total() == _markerCorners.total());
+
+    const float minRepDistanceRate = 1.302455f;
+
+    // create Charuco board layout for diamond (3x3 layout)
+    Ptr<Dictionary> dict = getPredefinedDictionary(PREDEFINED_DICTIONARY_NAME(0));
+    Ptr<CharucoBoard> _charucoDiamondLayout = CharucoBoard::create(3, 3, squareMarkerLengthRate, 1., dict);
+
+
+    vector< vector< Point2f > > diamondCorners;
+    vector< Vec4i > diamondIds;
+
+    // stores if the detected markers have been assigned or not to a diamond
+    vector< bool > assigned(_markerIds.total(), false);
+    if(_markerIds.total() < 4) return; // a diamond need at least 4 markers
+
+    // convert input image to grey
+    Mat grey;
+    if(_image.type() == CV_8UC3)
+        cvtColor(_image, grey, COLOR_BGR2GRAY);
+    else
+        _image.copyTo(grey);
+
+    // for each of the detected markers, try to find a diamond
+    for(unsigned int i = 0; i < _markerIds.total(); i++) {
+        if(assigned[i]) continue;
+
+        // calculate marker perimeter
+        float perimeterSq = 0;
+        Mat corners = _markerCorners.getMat(i);
+        for(int c = 0; c < 4; c++) {
+          Point2f edge = corners.at< Point2f >(c) - corners.at< Point2f >((c + 1) % 4);
+          perimeterSq += edge.x*edge.x + edge.y*edge.y;
+        }
+        // maximum reprojection error relative to perimeter
+        float minRepDistance = sqrt(perimeterSq) * minRepDistanceRate;
+
+        int currentId = _markerIds.getMat().at< int >(i);
+
+        // prepare data to call refineDetectedMarkers()
+        // detected markers (only the current one)
+        vector< Mat > currentMarker;
+        vector< int > currentMarkerId;
+        currentMarker.push_back(_markerCorners.getMat(i));
+        currentMarkerId.push_back(currentId);
+
+        // marker candidates (the rest of markers if they have not been assigned)
+        vector< Mat > candidates;
+        vector< int > candidatesIdxs;
+        for(unsigned int k = 0; k < assigned.size(); k++) {
+            if(k == i) continue;
+            if(!assigned[k]) {
+                candidates.push_back(_markerCorners.getMat(k));
+                candidatesIdxs.push_back(k);
+            }
+        }
+        if(candidates.size() < 3) break; // we need at least 3 free markers
+
+        // modify charuco layout id to make sure all the ids are different than current id
+        for(int k = 1; k < 4; k++)
+            _charucoDiamondLayout->ids[k] = currentId + 1 + k;
+        // current id is assigned to [0], so it is the marker on the top
+        _charucoDiamondLayout->ids[0] = currentId;
+
+        // try to find the rest of markers in the diamond
+        vector< int > acceptedIdxs;
+        Ptr<Board> _b = _charucoDiamondLayout.staticCast<Board>();
+        aruco::refineDetectedMarkers(grey, _b,
+                                     currentMarker, currentMarkerId,
+                                     candidates, noArray(), noArray(), minRepDistance, -1, false,
+                                     acceptedIdxs);
+
+        // if found, we have a diamond
+        if(currentMarker.size() == 4) {
+
+            assigned[i] = true;
+
+            // calculate diamond id, acceptedIdxs array indicates the markers taken from candidates
+            // array
+            Vec4i markerId;
+            markerId[0] = currentId;
+            for(int k = 1; k < 4; k++) {
+                int currentMarkerIdx = candidatesIdxs[acceptedIdxs[k - 1]];
+                markerId[k] = _markerIds.getMat().at< int >(currentMarkerIdx);
+                assigned[currentMarkerIdx] = true;
+            }
+
+            // interpolate the charuco corners of the diamond
+            vector< Point2f > currentMarkerCorners;
+            Mat aux;
+            interpolateCornersCharuco(currentMarker, currentMarkerId, grey, _charucoDiamondLayout,
+                                      currentMarkerCorners, aux, _cameraMatrix, _distCoeffs);
+
+            // if everything is ok, save the diamond
+            if(currentMarkerCorners.size() > 0) {
+                // reorder corners
+                vector< Point2f > currentMarkerCornersReorder;
+                currentMarkerCornersReorder.resize(4);
+                currentMarkerCornersReorder[0] = currentMarkerCorners[2];
+                currentMarkerCornersReorder[1] = currentMarkerCorners[3];
+                currentMarkerCornersReorder[2] = currentMarkerCorners[1];
+                currentMarkerCornersReorder[3] = currentMarkerCorners[0];
+
+                diamondCorners.push_back(currentMarkerCornersReorder);
+                diamondIds.push_back(markerId);
+            }
+        }
+    }
+
+
+    if(diamondIds.size() > 0) {
+        // parse output
+        Mat(diamondIds).copyTo(_diamondIds);
+
+        _diamondCorners.create((int)diamondCorners.size(), 1, CV_32FC2);
+        for(unsigned int i = 0; i < diamondCorners.size(); i++) {
+            _diamondCorners.create(4, 1, CV_32FC2, i, true);
+            for(int j = 0; j < 4; j++) {
+                _diamondCorners.getMat(i).at< Point2f >(j) = diamondCorners[i][j];
+            }
+        }
+    }
+}
+
+
+
+
+/**
+  */
+void drawCharucoDiamond(const Ptr<Dictionary> &dictionary, Vec4i ids, int squareLength, int markerLength,
+                        OutputArray _img, int marginSize, int borderBits) {
+
+    CV_Assert(squareLength > 0 && markerLength > 0 && squareLength > markerLength);
+    CV_Assert(marginSize >= 0 && borderBits > 0);
+
+    // create a charuco board similar to a charuco marker and print it
+    Ptr<CharucoBoard> board =
+        CharucoBoard::create(3, 3, (float)squareLength, (float)markerLength, dictionary);
+
+    // assign the charuco marker ids
+    for(int i = 0; i < 4; i++)
+        board->ids[i] = ids[i];
+
+    Size outSize(3 * squareLength + 2 * marginSize, 3 * squareLength + 2 * marginSize);
+    board->draw(outSize, _img, marginSize, borderBits);
+}
+
+
+/**
+ */
+void drawDetectedDiamonds(InputOutputArray _image, InputArrayOfArrays _corners,
+                          InputArray _ids, Scalar borderColor) {
+
+
+    CV_Assert(_image.getMat().total() != 0 &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_corners.total() == _ids.total()) || _ids.total() == 0);
+
+    // calculate colors
+    Scalar textColor, cornerColor;
+    textColor = cornerColor = borderColor;
+    swap(textColor.val[0], textColor.val[1]);     // text color just sawp G and R
+    swap(cornerColor.val[1], cornerColor.val[2]); // corner color just sawp G and B
+
+    int nMarkers = (int)_corners.total();
+    for(int i = 0; i < nMarkers; i++) {
+        Mat currentMarker = _corners.getMat(i);
+        CV_Assert(currentMarker.total() == 4 && currentMarker.type() == CV_32FC2);
+
+        // draw marker sides
+        for(int j = 0; j < 4; j++) {
+            Point2f p0, p1;
+            p0 = currentMarker.at< Point2f >(j);
+            p1 = currentMarker.at< Point2f >((j + 1) % 4);
+            line(_image, p0, p1, borderColor, 1);
+        }
+
+        // draw first corner mark
+        rectangle(_image, currentMarker.at< Point2f >(0) - Point2f(3, 3),
+                  currentMarker.at< Point2f >(0) + Point2f(3, 3), cornerColor, 1, LINE_AA);
+
+        // draw id composed by four numbers
+        if(_ids.total() != 0) {
+            Point2f cent(0, 0);
+            for(int p = 0; p < 4; p++)
+                cent += currentMarker.at< Point2f >(p);
+            cent = cent / 4.;
+            stringstream s;
+            s << "id=" << _ids.getMat().at< Vec4i >(i);
+            putText(_image, s.str(), cent, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 2);
+        }
+    }
+}
+}
+}

aruco_pose/vendor/aruco/src/dictionary.cpp

@@ -0,0 +1,494 @@
+/*
+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 "precomp.hpp"
+#include "opencv2/aruco/dictionary.hpp"
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include "predefined_dictionaries.hpp"
+#include "predefined_dictionaries_apriltag.hpp"
+#include "opencv2/core/hal/hal.hpp"
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+
+/**
+  */
+Dictionary::Dictionary(const Ptr<Dictionary> &_dictionary) {
+    markerSize = _dictionary->markerSize;
+    maxCorrectionBits = _dictionary->maxCorrectionBits;
+    bytesList = _dictionary->bytesList.clone();
+}
+
+
+/**
+  */
+Dictionary::Dictionary(const Mat &_bytesList, int _markerSize, int _maxcorr) {
+    markerSize = _markerSize;
+    maxCorrectionBits = _maxcorr;
+    bytesList = _bytesList;
+}
+
+
+/**
+ */
+Ptr<Dictionary> Dictionary::create(int nMarkers, int markerSize, int randomSeed) {
+    const Ptr<Dictionary> baseDictionary = makePtr<Dictionary>();
+    return create(nMarkers, markerSize, baseDictionary, randomSeed);
+}
+
+
+/**
+ */
+Ptr<Dictionary> Dictionary::create(int nMarkers, int markerSize,
+                                   const Ptr<Dictionary> &baseDictionary, int randomSeed) {
+
+    return generateCustomDictionary(nMarkers, markerSize, baseDictionary, randomSeed);
+}
+
+
+/**
+ */
+Ptr<Dictionary> Dictionary::get(int dict) {
+    return getPredefinedDictionary(dict);
+}
+
+
+/**
+ */
+bool Dictionary::identify(const Mat &onlyBits, int &idx, int &rotation,
+                          double maxCorrectionRate) const {
+
+    CV_Assert(onlyBits.rows == markerSize && onlyBits.cols == markerSize);
+
+    int maxCorrectionRecalculed = int(double(maxCorrectionBits) * maxCorrectionRate);
+
+    // get as a byte list
+    Mat candidateBytes = getByteListFromBits(onlyBits);
+
+    idx = -1; // by default, not found
+
+    // search closest marker in dict
+    for(int m = 0; m < bytesList.rows; m++) {
+        int currentMinDistance = markerSize * markerSize + 1;
+        int currentRotation = -1;
+        for(unsigned int r = 0; r < 4; r++) {
+            int currentHamming = cv::hal::normHamming(
+                    bytesList.ptr(m)+r*candidateBytes.cols,
+                    candidateBytes.ptr(),
+                    candidateBytes.cols);
+
+            if(currentHamming < currentMinDistance) {
+                currentMinDistance = currentHamming;
+                currentRotation = r;
+            }
+        }
+
+        // if maxCorrection is fullfilled, return this one
+        if(currentMinDistance <= maxCorrectionRecalculed) {
+            idx = m;
+            rotation = currentRotation;
+            break;
+        }
+    }
+
+    return idx != -1;
+}
+
+
+/**
+  */
+int Dictionary::getDistanceToId(InputArray bits, int id, bool allRotations) const {
+
+    CV_Assert(id >= 0 && id < bytesList.rows);
+
+    unsigned int nRotations = 4;
+    if(!allRotations) nRotations = 1;
+
+    Mat candidateBytes = getByteListFromBits(bits.getMat());
+    int currentMinDistance = int(bits.total() * bits.total());
+    for(unsigned int r = 0; r < nRotations; r++) {
+        int currentHamming = cv::hal::normHamming(
+                bytesList.ptr(id) + r*candidateBytes.cols,
+                candidateBytes.ptr(),
+                candidateBytes.cols);
+
+        if(currentHamming < currentMinDistance) {
+            currentMinDistance = currentHamming;
+        }
+    }
+    return currentMinDistance;
+}
+
+
+
+/**
+ * @brief Draw a canonical marker image
+ */
+void Dictionary::drawMarker(int id, int sidePixels, OutputArray _img, int borderBits) const {
+
+    CV_Assert(sidePixels >= (markerSize + 2*borderBits));
+    CV_Assert(id < bytesList.rows);
+    CV_Assert(borderBits > 0);
+
+    _img.create(sidePixels, sidePixels, CV_8UC1);
+
+    // create small marker with 1 pixel per bin
+    Mat tinyMarker(markerSize + 2 * borderBits, markerSize + 2 * borderBits, CV_8UC1,
+                   Scalar::all(0));
+    Mat innerRegion = tinyMarker.rowRange(borderBits, tinyMarker.rows - borderBits)
+                          .colRange(borderBits, tinyMarker.cols - borderBits);
+    // put inner bits
+    Mat bits = 255 * getBitsFromByteList(bytesList.rowRange(id, id + 1), markerSize);
+    CV_Assert(innerRegion.total() == bits.total());
+    bits.copyTo(innerRegion);
+
+    // resize tiny marker to output size
+    cv::resize(tinyMarker, _img.getMat(), _img.getMat().size(), 0, 0, INTER_NEAREST);
+}
+
+
+
+
+/**
+  * @brief Transform matrix of bits to list of bytes in the 4 rotations
+  */
+Mat Dictionary::getByteListFromBits(const Mat &bits) {
+    // integer ceil
+    int nbytes = (bits.cols * bits.rows + 8 - 1) / 8;
+
+    Mat candidateByteList(1, nbytes, CV_8UC4, Scalar::all(0));
+    unsigned char currentBit = 0;
+    int currentByte = 0;
+
+    // the 4 rotations
+    uchar* rot0 = candidateByteList.ptr();
+    uchar* rot1 = candidateByteList.ptr() + 1*nbytes;
+    uchar* rot2 = candidateByteList.ptr() + 2*nbytes;
+    uchar* rot3 = candidateByteList.ptr() + 3*nbytes;
+
+    for(int row = 0; row < bits.rows; row++) {
+        for(int col = 0; col < bits.cols; col++) {
+            // circular shift
+            rot0[currentByte] <<= 1;
+            rot1[currentByte] <<= 1;
+            rot2[currentByte] <<= 1;
+            rot3[currentByte] <<= 1;
+            // set bit
+            rot0[currentByte] |= bits.at<uchar>(row, col);
+            rot1[currentByte] |= bits.at<uchar>(col, bits.cols - 1 - row);
+            rot2[currentByte] |= bits.at<uchar>(bits.rows - 1 - row, bits.cols - 1 - col);
+            rot3[currentByte] |= bits.at<uchar>(bits.rows - 1 - col, row);
+            currentBit++;
+            if(currentBit == 8) {
+                // next byte
+                currentBit = 0;
+                currentByte++;
+            }
+        }
+    }
+    return candidateByteList;
+}
+
+
+
+/**
+  * @brief Transform list of bytes to matrix of bits
+  */
+Mat Dictionary::getBitsFromByteList(const Mat &byteList, int markerSize) {
+    CV_Assert(byteList.total() > 0 &&
+              byteList.total() >= (unsigned int)markerSize * markerSize / 8 &&
+              byteList.total() <= (unsigned int)markerSize * markerSize / 8 + 1);
+    Mat bits(markerSize, markerSize, CV_8UC1, Scalar::all(0));
+
+    unsigned char base2List[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
+    int currentByteIdx = 0;
+    // we only need the bytes in normal rotation
+    unsigned char currentByte = byteList.ptr()[0];
+    int currentBit = 0;
+    for(int row = 0; row < bits.rows; row++) {
+        for(int col = 0; col < bits.cols; col++) {
+            if(currentByte >= base2List[currentBit]) {
+                bits.at< unsigned char >(row, col) = 1;
+                currentByte -= base2List[currentBit];
+            }
+            currentBit++;
+            if(currentBit == 8) {
+                currentByteIdx++;
+                currentByte = byteList.ptr()[currentByteIdx];
+                // if not enough bits for one more byte, we are in the end
+                // update bit position accordingly
+                if(8 * (currentByteIdx + 1) > (int)bits.total())
+                    currentBit = 8 * (currentByteIdx + 1) - (int)bits.total();
+                else
+                    currentBit = 0; // ok, bits enough for next byte
+            }
+        }
+    }
+    return bits;
+}
+
+
+
+
+// DictionaryData constructors calls
+const Dictionary DICT_ARUCO_DATA = Dictionary(Mat(1024, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_ARUCO_BYTES), 5, 0);
+
+const Dictionary DICT_4X4_50_DATA = Dictionary(Mat(50, (4*4 + 7)/8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, 1);
+const Dictionary DICT_4X4_100_DATA = Dictionary(Mat(100, (4*4 + 7)/8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, 1);
+const Dictionary DICT_4X4_250_DATA = Dictionary(Mat(250, (4*4 + 7)/8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, 1);
+const Dictionary DICT_4X4_1000_DATA = Dictionary(Mat(1000, (4*4 + 7)/8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, 0);
+
+const Dictionary DICT_5X5_50_DATA = Dictionary(Mat(50, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, 3);
+const Dictionary DICT_5X5_100_DATA = Dictionary(Mat(100, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, 3);
+const Dictionary DICT_5X5_250_DATA = Dictionary(Mat(250, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, 2);
+const Dictionary DICT_5X5_1000_DATA = Dictionary(Mat(1000, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, 2);
+
+const Dictionary DICT_6X6_50_DATA = Dictionary(Mat(50, (6*6 + 7)/8 ,CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, 6);
+const Dictionary DICT_6X6_100_DATA = Dictionary(Mat(100, (6*6 + 7)/8 ,CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, 5);
+const Dictionary DICT_6X6_250_DATA = Dictionary(Mat(250, (6*6 + 7)/8 ,CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, 5);
+const Dictionary DICT_6X6_1000_DATA = Dictionary(Mat(1000, (6*6 + 7)/8 ,CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, 4);
+
+const Dictionary DICT_7X7_50_DATA = Dictionary(Mat(50, (7*7 + 7)/8 ,CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, 9);
+const Dictionary DICT_7X7_100_DATA = Dictionary(Mat(100, (7*7 + 7)/8 ,CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, 8);
+const Dictionary DICT_7X7_250_DATA = Dictionary(Mat(250, (7*7 + 7)/8 ,CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, 8);
+const Dictionary DICT_7X7_1000_DATA = Dictionary(Mat(1000, (7*7 + 7)/8 ,CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, 6);
+
+const Dictionary DICT_APRILTAG_16h5_DATA = Dictionary(Mat(30, (4*4 + 7)/8, CV_8UC4, (uchar*)DICT_APRILTAG_16h5_BYTES), 4, 0);
+const Dictionary DICT_APRILTAG_25h9_DATA = Dictionary(Mat(35, (5*5 + 7)/8, CV_8UC4, (uchar*)DICT_APRILTAG_25h9_BYTES), 5, 0);
+const Dictionary DICT_APRILTAG_36h10_DATA = Dictionary(Mat(2320, (6*6 + 7)/8, CV_8UC4, (uchar*)DICT_APRILTAG_36h10_BYTES), 6, 0);
+const Dictionary DICT_APRILTAG_36h11_DATA = Dictionary(Mat(587, (6*6 + 7)/8, CV_8UC4, (uchar*)DICT_APRILTAG_36h11_BYTES), 6, 0);
+
+
+Ptr<Dictionary> getPredefinedDictionary(PREDEFINED_DICTIONARY_NAME name) {
+    switch(name) {
+
+    case DICT_ARUCO_ORIGINAL:
+        return makePtr<Dictionary>(DICT_ARUCO_DATA);
+
+    case DICT_4X4_50:
+        return makePtr<Dictionary>(DICT_4X4_50_DATA);
+    case DICT_4X4_100:
+        return makePtr<Dictionary>(DICT_4X4_100_DATA);
+    case DICT_4X4_250:
+        return makePtr<Dictionary>(DICT_4X4_250_DATA);
+    case DICT_4X4_1000:
+        return makePtr<Dictionary>(DICT_4X4_1000_DATA);
+
+    case DICT_5X5_50:
+        return makePtr<Dictionary>(DICT_5X5_50_DATA);
+    case DICT_5X5_100:
+        return makePtr<Dictionary>(DICT_5X5_100_DATA);
+    case DICT_5X5_250:
+        return makePtr<Dictionary>(DICT_5X5_250_DATA);
+    case DICT_5X5_1000:
+        return makePtr<Dictionary>(DICT_5X5_1000_DATA);
+
+    case DICT_6X6_50:
+        return makePtr<Dictionary>(DICT_6X6_50_DATA);
+    case DICT_6X6_100:
+        return makePtr<Dictionary>(DICT_6X6_100_DATA);
+    case DICT_6X6_250:
+        return makePtr<Dictionary>(DICT_6X6_250_DATA);
+    case DICT_6X6_1000:
+        return makePtr<Dictionary>(DICT_6X6_1000_DATA);
+
+    case DICT_7X7_50:
+        return makePtr<Dictionary>(DICT_7X7_50_DATA);
+    case DICT_7X7_100:
+        return makePtr<Dictionary>(DICT_7X7_100_DATA);
+    case DICT_7X7_250:
+        return makePtr<Dictionary>(DICT_7X7_250_DATA);
+    case DICT_7X7_1000:
+        return makePtr<Dictionary>(DICT_7X7_1000_DATA);
+
+    case DICT_APRILTAG_16h5:
+        return makePtr<Dictionary>(DICT_APRILTAG_16h5_DATA);
+    case DICT_APRILTAG_25h9:
+        return makePtr<Dictionary>(DICT_APRILTAG_25h9_DATA);
+    case DICT_APRILTAG_36h10:
+        return makePtr<Dictionary>(DICT_APRILTAG_36h10_DATA);
+    case DICT_APRILTAG_36h11:
+        return makePtr<Dictionary>(DICT_APRILTAG_36h11_DATA);
+
+    }
+    return makePtr<Dictionary>(DICT_4X4_50_DATA);
+}
+
+
+Ptr<Dictionary> getPredefinedDictionary(int dict) {
+    return getPredefinedDictionary(PREDEFINED_DICTIONARY_NAME(dict));
+}
+
+
+/**
+ * @brief Generates a random marker Mat of size markerSize x markerSize
+ */
+static Mat _generateRandomMarker(int markerSize, RNG &rng) {
+    Mat marker(markerSize, markerSize, CV_8UC1, Scalar::all(0));
+    for(int i = 0; i < markerSize; i++) {
+        for(int j = 0; j < markerSize; j++) {
+            unsigned char bit = (unsigned char) (rng.uniform(0,2));
+            marker.at< unsigned char >(i, j) = bit;
+        }
+    }
+    return marker;
+}
+
+/**
+ * @brief Calculate selfDistance of the codification of a marker Mat. Self distance is the Hamming
+ * distance of the marker to itself in the other rotations.
+ * See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+ * "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+ * Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+ */
+static int _getSelfDistance(const Mat &marker) {
+    Mat bytes = Dictionary::getByteListFromBits(marker);
+    int minHamming = (int)marker.total() + 1;
+    for(int r = 1; r < 4; r++) {
+        int currentHamming = cv::hal::normHamming(bytes.ptr(), bytes.ptr() + bytes.cols*r, bytes.cols);
+        if(currentHamming < minHamming) minHamming = currentHamming;
+    }
+    return minHamming;
+}
+
+/**
+ */
+Ptr<Dictionary> generateCustomDictionary(int nMarkers, int markerSize,
+                                         const Ptr<Dictionary> &baseDictionary, int randomSeed) {
+    RNG rng((uint64)(randomSeed));
+
+    Ptr<Dictionary> out = makePtr<Dictionary>();
+    out->markerSize = markerSize;
+
+    // theoretical maximum intermarker distance
+    // See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+    // "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+    // Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+    int C = (int)std::floor(float(markerSize * markerSize) / 4.f);
+    int tau = 2 * (int)std::floor(float(C) * 4.f / 3.f);
+
+    // if baseDictionary is provided, calculate its intermarker distance
+    if(baseDictionary->bytesList.rows > 0) {
+        CV_Assert(baseDictionary->markerSize == markerSize);
+        out->bytesList = baseDictionary->bytesList.clone();
+
+        int minDistance = markerSize * markerSize + 1;
+        for(int i = 0; i < out->bytesList.rows; i++) {
+            Mat markerBytes = out->bytesList.rowRange(i, i + 1);
+            Mat markerBits = Dictionary::getBitsFromByteList(markerBytes, markerSize);
+            minDistance = min(minDistance, _getSelfDistance(markerBits));
+            for(int j = i + 1; j < out->bytesList.rows; j++) {
+                minDistance = min(minDistance, out->getDistanceToId(markerBits, j));
+            }
+        }
+        tau = minDistance;
+    }
+
+    // current best option
+    int bestTau = 0;
+    Mat bestMarker;
+
+    // after these number of unproductive iterations, the best option is accepted
+    const int maxUnproductiveIterations = 5000;
+    int unproductiveIterations = 0;
+
+    while(out->bytesList.rows < nMarkers) {
+        Mat currentMarker = _generateRandomMarker(markerSize, rng);
+
+        int selfDistance = _getSelfDistance(currentMarker);
+        int minDistance = selfDistance;
+
+        // if self distance is better or equal than current best option, calculate distance
+        // to previous accepted markers
+        if(selfDistance >= bestTau) {
+            for(int i = 0; i < out->bytesList.rows; i++) {
+                int currentDistance = out->getDistanceToId(currentMarker, i);
+                minDistance = min(currentDistance, minDistance);
+                if(minDistance <= bestTau) {
+                    break;
+                }
+            }
+        }
+
+        // if distance is high enough, accept the marker
+        if(minDistance >= tau) {
+            unproductiveIterations = 0;
+            bestTau = 0;
+            Mat bytes = Dictionary::getByteListFromBits(currentMarker);
+            out->bytesList.push_back(bytes);
+        } else {
+            unproductiveIterations++;
+
+            // if distance is not enough, but is better than the current best option
+            if(minDistance > bestTau) {
+                bestTau = minDistance;
+                bestMarker = currentMarker;
+            }
+
+            // if number of unproductive iterarions has been reached, accept the current best option
+            if(unproductiveIterations == maxUnproductiveIterations) {
+                unproductiveIterations = 0;
+                tau = bestTau;
+                bestTau = 0;
+                Mat bytes = Dictionary::getByteListFromBits(bestMarker);
+                out->bytesList.push_back(bytes);
+            }
+        }
+    }
+
+    // update the maximum number of correction bits for the generated dictionary
+    out->maxCorrectionBits = (tau - 1) / 2;
+
+    return out;
+}
+
+
+/**
+ */
+Ptr<Dictionary> generateCustomDictionary(int nMarkers, int markerSize, int randomSeed) {
+    Ptr<Dictionary> baseDictionary = makePtr<Dictionary>();
+    return generateCustomDictionary(nMarkers, markerSize, baseDictionary, randomSeed);
+}
+
+
+}
+}

aruco_pose/vendor/aruco/src/precomp.hpp

@@ -0,0 +1,49 @@
+/*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

aruco_pose/vendor/aruco/src/unionfind.hpp

@@ -0,0 +1,133 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_UNIONFIND_HPP_
+#define _OPENCV_UNIONFIND_HPP_
+
+#include <stdint.h>
+#include <stdlib.h>
+namespace cv {
+namespace aruco {
+
+typedef struct unionfind unionfind_t;
+struct unionfind{
+    uint32_t maxid;
+    struct ufrec *data;
+};
+
+struct ufrec{
+    // the parent of this node. If a node's parent is its own index,
+    // then it is a root.
+    uint32_t parent;
+
+    // for the root of a connected component, the number of components
+    // connected to it. For intermediate values, it's not meaningful.
+    uint32_t size;
+};
+
+static inline unionfind_t *unionfind_create(uint32_t maxid){
+    unionfind_t *uf = (unionfind_t*) calloc(1, sizeof(unionfind_t));
+    uf->maxid = maxid;
+    uf->data = (struct ufrec*) malloc((maxid+1) * sizeof(struct ufrec));
+    for (unsigned int i = 0; i <= maxid; i++) {
+        uf->data[i].size = 1;
+        uf->data[i].parent = i;
+    }
+    return uf;
+}
+
+static inline void unionfind_destroy(unionfind_t *uf){
+    free(uf->data);
+    free(uf);
+}
+
+/*
+static inline uint32_t unionfind_get_representative(unionfind_t *uf, uint32_t id)
+{
+    // base case: a node is its own parent
+    if (uf->data[id].parent == id)
+        return id;
+
+    // otherwise, recurse
+    uint32_t root = unionfind_get_representative(uf, uf->data[id].parent);
+
+    // short circuit the path. [XXX This write prevents tail recursion]
+    uf->data[id].parent = root;
+
+    return root;
+}
+ */
+
+// this one seems to be every-so-slightly faster than the recursive
+// version above.
+static inline uint32_t unionfind_get_representative(unionfind_t *uf, uint32_t id){
+    uint32_t root = id;
+
+    // chase down the root
+    while (uf->data[root].parent != root) {
+        root = uf->data[root].parent;
+    }
+
+    // go back and collapse the tree.
+    //
+    // XXX: on some of our workloads that have very shallow trees
+    // (e.g. image segmentation), we are actually faster not doing
+    // this...
+    while (uf->data[id].parent != root) {
+        uint32_t tmp = uf->data[id].parent;
+        uf->data[id].parent = root;
+        id = tmp;
+    }
+
+    return root;
+}
+
+static inline uint32_t unionfind_get_set_size(unionfind_t *uf, uint32_t id){
+    uint32_t repid = unionfind_get_representative(uf, id);
+    return uf->data[repid].size;
+}
+
+static inline uint32_t unionfind_connect(unionfind_t *uf, uint32_t aid, uint32_t bid){
+    uint32_t aroot = unionfind_get_representative(uf, aid);
+    uint32_t broot = unionfind_get_representative(uf, bid);
+
+    if (aroot == broot)
+        return aroot;
+
+    // we don't perform "union by rank", but we perform a similar
+    // operation (but probably without the same asymptotic guarantee):
+    // We join trees based on the number of *elements* (as opposed to
+    // rank) contained within each tree. I.e., we use size as a proxy
+    // for rank.  In my testing, it's often *faster* to use size than
+    // rank, perhaps because the rank of the tree isn't that critical
+    // if there are very few nodes in it.
+    uint32_t asize = uf->data[aroot].size;
+    uint32_t bsize = uf->data[broot].size;
+
+    // optimization idea: We could shortcut some or all of the tree
+    // that is grafted onto the other tree. Pro: those nodes were just
+    // read and so are probably in cache. Con: it might end up being
+    // wasted effort -- the tree might be grafted onto another tree in
+    // a moment!
+    if (asize > bsize) {
+        uf->data[broot].parent = aroot;
+        uf->data[aroot].size += bsize;
+        return aroot;
+    } else {
+        uf->data[aroot].parent = broot;
+        uf->data[broot].size += asize;
+        return broot;
+    }
+}
+}}
+#endif

aruco_pose/vendor/aruco/src/zarray.hpp

@@ -0,0 +1,150 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZARRAY_HPP_
+#define _OPENCV_ZARRAY_HPP_
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace cv {
+namespace aruco {
+
+
+struct sQuad{
+    float p[4][2]; // corners
+};
+
+/**
+ * Defines a structure which acts as a resize-able array ala Java's ArrayList.
+ */
+typedef struct zarray zarray_t;
+struct zarray{
+    size_t el_sz; // size of each element
+
+    int size; // how many elements?
+    int alloc; // we've allocated storage for how many elements?
+    char *data;
+};
+
+/**
+ * Creates and returns a variable array structure capable of holding elements of
+ * the specified size. It is the caller's responsibility to call zarray_destroy()
+ * on the returned array when it is no longer needed.
+ */
+inline static zarray_t *_zarray_create(size_t el_sz){
+    zarray_t *za = (zarray_t*) calloc(1, sizeof(zarray_t));
+    za->el_sz = el_sz;
+    return za;
+}
+
+/**
+ * Frees all resources associated with the variable array structure which was
+ * created by zarray_create(). After calling, 'za' will no longer be valid for storage.
+ */
+inline static void _zarray_destroy(zarray_t *za){
+    if (za == NULL)
+        return;
+
+    if (za->data != NULL)
+        free(za->data);
+    memset(za, 0, sizeof(zarray_t));
+    free(za);
+}
+
+/**
+ * Retrieves the number of elements currently being contained by the passed
+ * array, which may be different from its capacity. The index of the last element
+ * in the array will be one less than the returned value.
+ */
+inline static int _zarray_size(const zarray_t *za){
+    return za->size;
+}
+
+/**
+ * Allocates enough internal storage in the supplied variable array structure to
+ * guarantee that the supplied number of elements (capacity) can be safely stored.
+ */
+inline static void _zarray_ensure_capacity(zarray_t *za, int capacity){
+    if (capacity <= za->alloc)
+        return;
+
+    while (za->alloc < capacity) {
+        za->alloc *= 2;
+        if (za->alloc < 8)
+            za->alloc = 8;
+    }
+
+    za->data = (char*) realloc(za->data, za->alloc * za->el_sz);
+}
+
+/**
+ * Adds a new element to the end of the supplied array, and sets its value
+ * (by copying) from the data pointed to by the supplied pointer 'p'.
+ * Automatically ensures that enough storage space is available for the new element.
+ */
+inline static void _zarray_add(zarray_t *za, const void *p){
+    _zarray_ensure_capacity(za, za->size + 1);
+
+    memcpy(&za->data[za->size*za->el_sz], p, za->el_sz);
+    za->size++;
+}
+
+/**
+ * Retrieves the element from the supplied array located at the zero-based
+ * index of 'idx' and copies its value into the variable pointed to by the pointer
+ * 'p'.
+ */
+inline static void _zarray_get(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    memcpy(p, &za->data[idx*za->el_sz], za->el_sz);
+}
+
+/**
+ * Similar to zarray_get(), but returns a "live" pointer to the internal
+ * storage, avoiding a memcpy. This pointer is not valid across
+ * operations which might move memory around (i.e. zarray_remove_value(),
+ * zarray_remove_index(), zarray_insert(), zarray_sort(), zarray_clear()).
+ * 'p' should be a pointer to the pointer which will be set to the internal address.
+ */
+inline static void _zarray_get_volatile(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    *((void**) p) = &za->data[idx*za->el_sz];
+}
+
+inline static void _zarray_truncate(zarray_t *za, int sz){
+    za->size = sz;
+}
+
+/**
+ * Sets the value of the current element at index 'idx' by copying its value from
+ * the data pointed to by 'p'. The previous value of the changed element will be
+ * copied into the data pointed to by 'outp' if it is not null.
+ */
+static inline void _zarray_set(zarray_t *za, int idx, const void *p, void *outp){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    if (outp != NULL)
+        memcpy(outp, &za->data[idx*za->el_sz], za->el_sz);
+
+    memcpy(&za->data[idx*za->el_sz], p, za->el_sz);
+}
+
+}
+}
+#endif

aruco_pose/vendor/aruco/src/zmaxheap.cpp

@@ -0,0 +1,208 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+#include "precomp.hpp"
+#include "zmaxheap.hpp"
+
+
+//                 0
+//         1               2
+//      3     4        5       6
+//     7 8   9 10    11 12   13 14
+//
+// Children of node i:  2*i+1, 2*i+2
+// Parent of node i: (i-1) / 2
+//
+// Heap property: a parent is greater than (or equal to) its children.
+
+#define MIN_CAPACITY 16
+namespace cv {
+namespace aruco {
+struct zmaxheap
+{
+    size_t el_sz;
+
+    int size;
+    int alloc;
+
+    float *values;
+    char *data;
+
+    void (*swap)(zmaxheap_t *heap, int a, int b);
+};
+
+static inline void _swap_default(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    cv::AutoBuffer<char> tmp(heap->el_sz);
+	/* NOTE: OpenCV v<3.3 does not have .data() member for AutoBuffer */
+    memcpy(tmp, &heap->data[a*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[a*heap->el_sz], &heap->data[b*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[b*heap->el_sz], tmp, heap->el_sz);
+}
+
+static inline void _swap_pointer(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    void **pp = (void**) heap->data;
+    void *tmp = pp[a];
+    pp[a] = pp[b];
+    pp[b] = tmp;
+}
+
+
+zmaxheap_t *zmaxheap_create(size_t el_sz)
+{
+    zmaxheap_t *heap = (zmaxheap_t*)calloc(1, sizeof(zmaxheap_t));
+    heap->el_sz = el_sz;
+
+    heap->swap = _swap_default;
+
+    if (el_sz == sizeof(void*))
+        heap->swap = _swap_pointer;
+
+    return heap;
+}
+
+void zmaxheap_destroy(zmaxheap_t *heap)
+{
+    free(heap->values);
+    free(heap->data);
+    memset(heap, 0, sizeof(zmaxheap_t));
+    free(heap);
+}
+
+static void _zmaxheap_ensure_capacity(zmaxheap_t *heap, int capacity)
+{
+    if (heap->alloc >= capacity)
+        return;
+
+    int newcap = heap->alloc;
+
+    while (newcap < capacity) {
+        if (newcap < MIN_CAPACITY) {
+            newcap = MIN_CAPACITY;
+            continue;
+        }
+
+        newcap *= 2;
+    }
+
+    heap->values = (float*)realloc(heap->values, newcap * sizeof(float));
+    heap->data = (char*)realloc(heap->data, newcap * heap->el_sz);
+    heap->alloc = newcap;
+}
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v)
+{
+    _zmaxheap_ensure_capacity(heap, heap->size + 1);
+
+    int idx = heap->size;
+
+    heap->values[idx] = v;
+    memcpy(&heap->data[idx*heap->el_sz], p, heap->el_sz);
+
+    heap->size++;
+
+    while (idx > 0) {
+
+        int parent = (idx - 1) / 2;
+
+        // we're done!
+        if (heap->values[parent] >= v)
+            break;
+
+        // else, swap and recurse upwards.
+        heap->swap(heap, idx, parent);
+        idx = parent;
+    }
+}
+
+// Removes the item in the heap at the given index.  Returns 1 if the
+// item existed. 0 Indicates an invalid idx (heap is smaller than
+// idx). This is mostly intended to be used by zmaxheap_remove_max.
+static int zmaxheap_remove_index(zmaxheap_t *heap, int idx, void *p, float *v)
+{
+    if (idx >= heap->size)
+        return 0;
+
+    // copy out the requested element from the heap.
+    if (v != NULL)
+        *v = heap->values[idx];
+    if (p != NULL)
+        memcpy(p, &heap->data[idx*heap->el_sz], heap->el_sz);
+
+    heap->size--;
+
+    // If this element is already the last one, then there's nothing
+    // for us to do.
+    if (idx == heap->size)
+        return 1;
+
+    // copy last element to first element. (which probably upsets
+    // the heap property).
+    heap->values[idx] = heap->values[heap->size];
+    memcpy(&heap->data[idx*heap->el_sz], &heap->data[heap->el_sz * heap->size], heap->el_sz);
+
+    // now fix the heap. Note, as we descend, we're "pushing down"
+    // the same node the entire time. Thus, while the index of the
+    // parent might change, the parent_score doesn't.
+    int parent = idx;
+    float parent_score = heap->values[idx];
+
+    // descend, fixing the heap.
+    while (parent < heap->size) {
+
+        int left = 2*parent + 1;
+        int right = left + 1;
+
+//            assert(parent_score == heap->values[parent]);
+
+        float left_score = (left < heap->size) ? heap->values[left] : -INFINITY;
+        float right_score = (right < heap->size) ? heap->values[right] : -INFINITY;
+
+        // put the biggest of (parent, left, right) as the parent.
+
+        // already okay?
+        if (parent_score >= left_score && parent_score >= right_score)
+            break;
+
+        // if we got here, then one of the children is bigger than the parent.
+        if (left_score >= right_score) {
+            CV_Assert(left < heap->size);
+            heap->swap(heap, parent, left);
+            parent = left;
+        } else {
+            // right_score can't be less than left_score if right_score is -INFINITY.
+            CV_Assert(right < heap->size);
+            heap->swap(heap, parent, right);
+            parent = right;
+        }
+    }
+
+    return 1;
+}
+
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v)
+{
+    return zmaxheap_remove_index(heap, 0, p, v);
+}
+
+}}

aruco_pose/vendor/aruco/src/zmaxheap.hpp

@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZMAXHEAP_HPP_
+#define _OPENCV_ZMAXHEAP_HPP_
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+namespace cv {
+namespace aruco {
+typedef struct zmaxheap zmaxheap_t;
+
+typedef struct zmaxheap_iterator zmaxheap_iterator_t;
+struct zmaxheap_iterator {
+    zmaxheap_t *heap;
+    int in, out;
+};
+
+zmaxheap_t *zmaxheap_create(size_t el_sz);
+
+void zmaxheap_destroy(zmaxheap_t *heap);
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v);
+
+// returns 0 if the heap is empty, so you can do
+// while (zmaxheap_remove_max(...)) { }
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v);
+
+}}
+#endif

aruco_pose/vendor/aruco/test/test_arucodetection.cpp

@@ -0,0 +1,571 @@
+/*
+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 "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+/**
+ * @brief Draw 2D synthetic markers and detect them
+ */
+class CV_ArucoDetectionSimple : public cvtest::BaseTest {
+    public:
+    CV_ArucoDetectionSimple();
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoDetectionSimple::CV_ArucoDetectionSimple() {}
+
+
+void CV_ArucoDetectionSimple::run(int) {
+
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+
+    // 20 images
+    for(int i = 0; i < 20; i++) {
+
+        const int markerSidePixels = 100;
+        int imageSize = markerSidePixels * 2 + 3 * (markerSidePixels / 2);
+
+        // draw synthetic image and store marker corners and ids
+        vector< vector< Point2f > > groundTruthCorners;
+        vector< int > groundTruthIds;
+        Mat img = Mat(imageSize, imageSize, CV_8UC1, Scalar::all(255));
+        for(int y = 0; y < 2; y++) {
+            for(int x = 0; x < 2; x++) {
+                Mat marker;
+                int id = i * 4 + y * 2 + x;
+                aruco::drawMarker(dictionary, id, markerSidePixels, marker);
+                Point2f firstCorner =
+                    Point2f(markerSidePixels / 2.f + x * (1.5f * markerSidePixels),
+                            markerSidePixels / 2.f + y * (1.5f * markerSidePixels));
+                Mat aux = img.colRange((int)firstCorner.x, (int)firstCorner.x + markerSidePixels)
+                              .rowRange((int)firstCorner.y, (int)firstCorner.y + markerSidePixels);
+                marker.copyTo(aux);
+                groundTruthIds.push_back(id);
+                groundTruthCorners.push_back(vector< Point2f >());
+                groundTruthCorners.back().push_back(firstCorner);
+                groundTruthCorners.back().push_back(firstCorner + Point2f(markerSidePixels - 1, 0));
+                groundTruthCorners.back().push_back(
+                    firstCorner + Point2f(markerSidePixels - 1, markerSidePixels - 1));
+                groundTruthCorners.back().push_back(firstCorner + Point2f(0, markerSidePixels - 1));
+            }
+        }
+        if(i % 2 == 1) img.convertTo(img, CV_8UC3);
+
+        // detect markers
+        vector< vector< Point2f > > corners;
+        vector< int > ids;
+        Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+
+        aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+        // check detection results
+        for(unsigned int m = 0; m < groundTruthIds.size(); m++) {
+            int idx = -1;
+            for(unsigned int k = 0; k < ids.size(); k++) {
+                if(groundTruthIds[m] == ids[k]) {
+                    idx = (int)k;
+                    break;
+                }
+            }
+            if(idx == -1) {
+                ts->printf(cvtest::TS::LOG, "Marker not detected");
+                ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                return;
+            }
+
+            for(int c = 0; c < 4; c++) {
+                double dist = cv::norm(groundTruthCorners[m][c] - corners[idx][c]);  // TODO cvtest
+                if(dist > 0.001) {
+                    ts->printf(cvtest::TS::LOG, "Incorrect marker corners position");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                    return;
+                }
+            }
+        }
+    }
+}
+
+
+static double deg2rad(double deg) { return deg * CV_PI / 180.; }
+
+/**
+ * @brief Get rvec and tvec from yaw, pitch and distance
+ */
+static void getSyntheticRT(double yaw, double pitch, double distance, Mat &rvec, Mat &tvec) {
+
+    rvec = Mat(3, 1, CV_64FC1);
+    tvec = Mat(3, 1, CV_64FC1);
+
+    // Rvec
+    // first put the Z axis aiming to -X (like the camera axis system)
+    Mat rotZ(3, 1, CV_64FC1);
+    rotZ.ptr< double >(0)[0] = 0;
+    rotZ.ptr< double >(0)[1] = 0;
+    rotZ.ptr< double >(0)[2] = -0.5 * CV_PI;
+
+    Mat rotX(3, 1, CV_64FC1);
+    rotX.ptr< double >(0)[0] = 0.5 * CV_PI;
+    rotX.ptr< double >(0)[1] = 0;
+    rotX.ptr< double >(0)[2] = 0;
+
+    Mat camRvec, camTvec;
+    composeRT(rotZ, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotX, Mat(3, 1, CV_64FC1, Scalar::all(0)),
+              camRvec, camTvec);
+
+    // now pitch and yaw angles
+    Mat rotPitch(3, 1, CV_64FC1);
+    rotPitch.ptr< double >(0)[0] = 0;
+    rotPitch.ptr< double >(0)[1] = pitch;
+    rotPitch.ptr< double >(0)[2] = 0;
+
+    Mat rotYaw(3, 1, CV_64FC1);
+    rotYaw.ptr< double >(0)[0] = yaw;
+    rotYaw.ptr< double >(0)[1] = 0;
+    rotYaw.ptr< double >(0)[2] = 0;
+
+    composeRT(rotPitch, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotYaw,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // compose both rotations
+    composeRT(camRvec, Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // Tvec, just move in z (camera) direction the specific distance
+    tvec.ptr< double >(0)[0] = 0.;
+    tvec.ptr< double >(0)[1] = 0.;
+    tvec.ptr< double >(0)[2] = distance;
+}
+
+/**
+ * @brief Create a synthetic image of a marker with perspective
+ */
+static Mat projectMarker(Ptr<aruco::Dictionary> &dictionary, int id, Mat cameraMatrix, double yaw,
+                         double pitch, double distance, Size imageSize, int markerBorder,
+                         vector< Point2f > &corners, int encloseMarker=0) {
+
+    // canonical image
+    Mat marker, markerImg;
+    const int markerSizePixels = 100;
+
+    aruco::drawMarker(dictionary, id, markerSizePixels, marker, markerBorder);
+    marker.copyTo(markerImg);
+
+    if(encloseMarker){ //to enclose the marker
+        int enclose = int(marker.rows/4);
+        markerImg = Mat::zeros(marker.rows+(2*enclose), marker.cols+(enclose*2), CV_8UC1);
+
+        Mat field= markerImg.rowRange(int(enclose), int(markerImg.rows-enclose))
+                            .colRange(int(0), int(markerImg.cols));
+        field.setTo(255);
+        field= markerImg.rowRange(int(0), int(markerImg.rows))
+                            .colRange(int(enclose), int(markerImg.cols-enclose));
+        field.setTo(255);
+
+        field = markerImg(Rect(enclose,enclose,marker.rows,marker.cols));
+        marker.copyTo(field);
+    }
+
+    // get rvec and tvec for the perspective
+    Mat rvec, tvec;
+    getSyntheticRT(yaw, pitch, distance, rvec, tvec);
+
+    const float markerLength = 0.05f;
+    vector< Point3f > markerObjPoints;
+    markerObjPoints.push_back(Point3f(-markerLength / 2.f, +markerLength / 2.f, 0));
+    markerObjPoints.push_back(markerObjPoints[0] + Point3f(markerLength, 0, 0));
+    markerObjPoints.push_back(markerObjPoints[0] + Point3f(markerLength, -markerLength, 0));
+    markerObjPoints.push_back(markerObjPoints[0] + Point3f(0, -markerLength, 0));
+
+    // project markers and draw them
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    projectPoints(markerObjPoints, rvec, tvec, cameraMatrix, distCoeffs, corners);
+
+    vector< Point2f > originalCorners;
+    originalCorners.push_back(Point2f(0+float(encloseMarker*markerSizePixels/4), 0+float(encloseMarker*markerSizePixels/4)));
+    originalCorners.push_back(originalCorners[0]+Point2f((float)markerSizePixels, 0));
+    originalCorners.push_back(originalCorners[0]+Point2f((float)markerSizePixels, (float)markerSizePixels));
+    originalCorners.push_back(originalCorners[0]+Point2f(0, (float)markerSizePixels));
+
+    Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+    Mat img(imageSize, CV_8UC1, Scalar::all(255));
+    Mat aux;
+    const char borderValue = 127;
+    warpPerspective(markerImg, aux, transformation, imageSize, INTER_NEAREST, BORDER_CONSTANT,
+                    Scalar::all(borderValue));
+
+    // copy only not-border pixels
+    for(int y = 0; y < aux.rows; y++) {
+        for(int x = 0; x < aux.cols; x++) {
+            if(aux.at< unsigned char >(y, x) == borderValue) continue;
+            img.at< unsigned char >(y, x) = aux.at< unsigned char >(y, x);
+        }
+    }
+
+    return img;
+}
+
+
+
+/**
+ * @brief Draws markers in perspective and detect them
+ */
+class CV_ArucoDetectionPerspective : public cvtest::BaseTest {
+    public:
+    CV_ArucoDetectionPerspective();
+
+    enum checkWithParameter{
+        USE_APRILTAG=1,             /// Detect marker candidates :: using AprilTag
+        DETECT_INVERTED_MARKER,     /// Check if there is a white marker
+    };
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoDetectionPerspective::CV_ArucoDetectionPerspective() {}
+
+
+void CV_ArucoDetectionPerspective::run(int tryWith) {
+
+    int iter = 0;
+    int szEnclosed = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+
+    // detect from different positions
+    for(double distance = 0.1; distance < 0.7; distance += 0.2) {
+        for(int pitch = 0; pitch < 360; pitch += (distance == 0.1? 60:180)) {
+            for(int yaw = 70; yaw <= 120; yaw += 40){
+                int currentId = iter % 250;
+                int markerBorder = iter % 2 + 1;
+                iter++;
+                vector< Point2f > groundTruthCorners;
+
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 1;
+                params->markerBorderBits = markerBorder;
+
+                /// create synthetic image
+                Mat img=
+                    projectMarker(dictionary, currentId, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                      distance, imgSize, markerBorder, groundTruthCorners, szEnclosed);
+                // marker :: Inverted
+                if(CV_ArucoDetectionPerspective::DETECT_INVERTED_MARKER == tryWith){
+                    img = ~img;
+                    params->detectInvertedMarker = true;
+                }
+
+                if(CV_ArucoDetectionPerspective::USE_APRILTAG == tryWith){
+                    params->cornerRefinementMethod = cv::aruco::CORNER_REFINE_APRILTAG;
+                }
+
+                // detect markers
+                vector< vector< Point2f > > corners;
+                vector< int > ids;
+                aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                // check results
+                if(ids.size() != 1 || (ids.size() == 1 && ids[0] != currentId)) {
+                    if(ids.size() != 1)
+                        ts->printf(cvtest::TS::LOG, "Incorrect number of detected markers");
+                    else
+                        ts->printf(cvtest::TS::LOG, "Incorrect marker id");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+                for(int c = 0; c < 4; c++) {
+                    double dist = cv::norm(groundTruthCorners[c] - corners[0][c]);  // TODO cvtest
+                    if(CV_ArucoDetectionPerspective::DETECT_INVERTED_MARKER == tryWith){
+                        if(szEnclosed && dist > 3){
+                            ts->printf(cvtest::TS::LOG, "Incorrect marker corners position");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                            return;
+                        }
+                        if(!szEnclosed && dist >15){
+                            ts->printf(cvtest::TS::LOG, "Incorrect marker corners position");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                            return;
+                        }
+                    }
+                    else{
+                        if(dist > 5) {
+                            ts->printf(cvtest::TS::LOG, "Incorrect marker corners position");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        // change the state :: to detect an enclosed inverted marker
+        if( CV_ArucoDetectionPerspective::DETECT_INVERTED_MARKER == tryWith && distance == 0.1 ){
+            distance -= 0.1;
+            szEnclosed++;
+        }
+    }
+}
+
+
+/**
+ * @brief Check max and min size in marker detection parameters
+ */
+class CV_ArucoDetectionMarkerSize : public cvtest::BaseTest {
+    public:
+    CV_ArucoDetectionMarkerSize();
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoDetectionMarkerSize::CV_ArucoDetectionMarkerSize() {}
+
+
+void CV_ArucoDetectionMarkerSize::run(int) {
+
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    int markerSide = 20;
+    int imageSize = 200;
+
+    // 10 cases
+    for(int i = 0; i < 10; i++) {
+        Mat marker;
+        int id = 10 + i * 20;
+
+        // create synthetic image
+        Mat img = Mat(imageSize, imageSize, CV_8UC1, Scalar::all(255));
+        aruco::drawMarker(dictionary, id, markerSide, marker);
+        Mat aux = img.colRange(30, 30 + markerSide).rowRange(50, 50 + markerSide);
+        marker.copyTo(aux);
+
+        vector< vector< Point2f > > corners;
+        vector< int > ids;
+        Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+
+        // set a invalid minMarkerPerimeterRate
+        params->minMarkerPerimeterRate = min(4., (4. * markerSide) / float(imageSize) + 0.1);
+        aruco::detectMarkers(img, dictionary, corners, ids, params);
+        if(corners.size() != 0) {
+            ts->printf(cvtest::TS::LOG, "Error in DetectorParameters::minMarkerPerimeterRate");
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            return;
+        }
+
+        // set an valid minMarkerPerimeterRate
+        params->minMarkerPerimeterRate = max(0., (4. * markerSide) / float(imageSize) - 0.1);
+        aruco::detectMarkers(img, dictionary, corners, ids, params);
+        if(corners.size() != 1 || (corners.size() == 1 && ids[0] != id)) {
+            ts->printf(cvtest::TS::LOG, "Error in DetectorParameters::minMarkerPerimeterRate");
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            return;
+        }
+
+        // set a invalid maxMarkerPerimeterRate
+        params->maxMarkerPerimeterRate = min(4., (4. * markerSide) / float(imageSize) - 0.1);
+        aruco::detectMarkers(img, dictionary, corners, ids, params);
+        if(corners.size() != 0) {
+            ts->printf(cvtest::TS::LOG, "Error in DetectorParameters::maxMarkerPerimeterRate");
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            return;
+        }
+
+        // set an valid maxMarkerPerimeterRate
+        params->maxMarkerPerimeterRate = max(0., (4. * markerSide) / float(imageSize) + 0.1);
+        aruco::detectMarkers(img, dictionary, corners, ids, params);
+        if(corners.size() != 1 || (corners.size() == 1 && ids[0] != id)) {
+            ts->printf(cvtest::TS::LOG, "Error in DetectorParameters::maxMarkerPerimeterRate");
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            return;
+        }
+    }
+}
+
+
+/**
+ * @brief Check error correction in marker bits
+ */
+class CV_ArucoBitCorrection : public cvtest::BaseTest {
+    public:
+    CV_ArucoBitCorrection();
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoBitCorrection::CV_ArucoBitCorrection() {}
+
+
+void CV_ArucoBitCorrection::run(int) {
+
+    Ptr<aruco::Dictionary> _dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    aruco::Dictionary &dictionary = *_dictionary;
+    aruco::Dictionary dictionary2 = *_dictionary;
+    int markerSide = 50;
+    int imageSize = 150;
+    Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+
+    // 10 markers
+    for(int l = 0; l < 10; l++) {
+        Mat marker;
+        int id = 10 + l * 20;
+
+        Mat currentCodeBytes = dictionary.bytesList.rowRange(id, id + 1);
+
+        // 5 valid cases
+        for(int i = 0; i < 5; i++) {
+            // how many bit errors (the error is low enough so it can be corrected)
+            params->errorCorrectionRate = 0.2 + i * 0.1;
+            int errors =
+                (int)std::floor(dictionary.maxCorrectionBits * params->errorCorrectionRate - 1.);
+
+            // create erroneous marker in currentCodeBits
+            Mat currentCodeBits =
+                aruco::Dictionary::getBitsFromByteList(currentCodeBytes, dictionary.markerSize);
+            for(int e = 0; e < errors; e++) {
+                currentCodeBits.ptr< unsigned char >()[2 * e] =
+                    !currentCodeBits.ptr< unsigned char >()[2 * e];
+            }
+
+            // add erroneous marker to dictionary2 in order to create the erroneous marker image
+            Mat currentCodeBytesError = aruco::Dictionary::getByteListFromBits(currentCodeBits);
+            currentCodeBytesError.copyTo(dictionary2.bytesList.rowRange(id, id + 1));
+            Mat img = Mat(imageSize, imageSize, CV_8UC1, Scalar::all(255));
+            dictionary2.drawMarker(id, markerSide, marker);
+            Mat aux = img.colRange(30, 30 + markerSide).rowRange(50, 50 + markerSide);
+            marker.copyTo(aux);
+
+            // try to detect using original dictionary
+            vector< vector< Point2f > > corners;
+            vector< int > ids;
+            aruco::detectMarkers(img, _dictionary, corners, ids, params);
+            if(corners.size() != 1 || (corners.size() == 1 && ids[0] != id)) {
+                ts->printf(cvtest::TS::LOG, "Error in bit correction");
+                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                return;
+            }
+        }
+
+        // 5 invalid cases
+        for(int i = 0; i < 5; i++) {
+            // how many bit errors (the error is too high to be corrected)
+            params->errorCorrectionRate = 0.2 + i * 0.1;
+            int errors =
+                (int)std::floor(dictionary.maxCorrectionBits * params->errorCorrectionRate + 1.);
+
+            // create erroneous marker in currentCodeBits
+            Mat currentCodeBits =
+                aruco::Dictionary::getBitsFromByteList(currentCodeBytes, dictionary.markerSize);
+            for(int e = 0; e < errors; e++) {
+                currentCodeBits.ptr< unsigned char >()[2 * e] =
+                    !currentCodeBits.ptr< unsigned char >()[2 * e];
+            }
+
+            // dictionary3 is only composed by the modified marker (in its original form)
+            Ptr<aruco::Dictionary> _dictionary3 = makePtr<aruco::Dictionary>(
+                    dictionary2.bytesList.rowRange(id, id + 1).clone(),
+                    dictionary.markerSize,
+                    dictionary.maxCorrectionBits);
+
+            // add erroneous marker to dictionary2 in order to create the erroneous marker image
+            Mat currentCodeBytesError = aruco::Dictionary::getByteListFromBits(currentCodeBits);
+            currentCodeBytesError.copyTo(dictionary2.bytesList.rowRange(id, id + 1));
+            Mat img = Mat(imageSize, imageSize, CV_8UC1, Scalar::all(255));
+            dictionary2.drawMarker(id, markerSide, marker);
+            Mat aux = img.colRange(30, 30 + markerSide).rowRange(50, 50 + markerSide);
+            marker.copyTo(aux);
+
+            // try to detect using dictionary3, it should fail
+            vector< vector< Point2f > > corners;
+            vector< int > ids;
+            aruco::detectMarkers(img, _dictionary3, corners, ids, params);
+            if(corners.size() != 0) {
+                ts->printf(cvtest::TS::LOG, "Error in DetectorParameters::errorCorrectionRate");
+                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+                return;
+            }
+        }
+    }
+}
+
+typedef CV_ArucoDetectionPerspective CV_AprilTagDetectionPerspective;
+typedef CV_ArucoDetectionPerspective CV_InvertedArucoDetectionPerspective;
+
+TEST(CV_InvertedArucoDetectionPerspective, algorithmic) {
+    CV_InvertedArucoDetectionPerspective test;
+    test.safe_run(CV_ArucoDetectionPerspective::DETECT_INVERTED_MARKER);
+}
+
+TEST(CV_AprilTagDetectionPerspective, algorithmic) {
+    CV_AprilTagDetectionPerspective test;
+    test.safe_run(CV_ArucoDetectionPerspective::USE_APRILTAG);
+}
+
+TEST(CV_ArucoDetectionSimple, algorithmic) {
+    CV_ArucoDetectionSimple test;
+    test.safe_run();
+}
+
+TEST(CV_ArucoDetectionPerspective, algorithmic) {
+    CV_ArucoDetectionPerspective test;
+    test.safe_run();
+}
+
+TEST(CV_ArucoDetectionMarkerSize, algorithmic) {
+    CV_ArucoDetectionMarkerSize test;
+    test.safe_run();
+}
+
+TEST(CV_ArucoBitCorrection, algorithmic) {
+    CV_ArucoBitCorrection test;
+    test.safe_run();
+}
+
+}} // namespace

aruco_pose/vendor/aruco/test/test_boarddetection.cpp

@@ -0,0 +1,407 @@
+/*
+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 "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static double deg2rad(double deg) { return deg * CV_PI / 180.; }
+
+/**
+ * @brief Get rvec and tvec from yaw, pitch and distance
+ */
+static void getSyntheticRT(double yaw, double pitch, double distance, Mat &rvec, Mat &tvec) {
+
+    rvec = Mat(3, 1, CV_64FC1);
+    tvec = Mat(3, 1, CV_64FC1);
+
+    // Rvec
+    // first put the Z axis aiming to -X (like the camera axis system)
+    Mat rotZ(3, 1, CV_64FC1);
+    rotZ.ptr< double >(0)[0] = 0;
+    rotZ.ptr< double >(0)[1] = 0;
+    rotZ.ptr< double >(0)[2] = -0.5 * CV_PI;
+
+    Mat rotX(3, 1, CV_64FC1);
+    rotX.ptr< double >(0)[0] = 0.5 * CV_PI;
+    rotX.ptr< double >(0)[1] = 0;
+    rotX.ptr< double >(0)[2] = 0;
+
+    Mat camRvec, camTvec;
+    composeRT(rotZ, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotX, Mat(3, 1, CV_64FC1, Scalar::all(0)),
+              camRvec, camTvec);
+
+    // now pitch and yaw angles
+    Mat rotPitch(3, 1, CV_64FC1);
+    rotPitch.ptr< double >(0)[0] = 0;
+    rotPitch.ptr< double >(0)[1] = pitch;
+    rotPitch.ptr< double >(0)[2] = 0;
+
+    Mat rotYaw(3, 1, CV_64FC1);
+    rotYaw.ptr< double >(0)[0] = yaw;
+    rotYaw.ptr< double >(0)[1] = 0;
+    rotYaw.ptr< double >(0)[2] = 0;
+
+    composeRT(rotPitch, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotYaw,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // compose both rotations
+    composeRT(camRvec, Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // Tvec, just move in z (camera) direction the specific distance
+    tvec.ptr< double >(0)[0] = 0.;
+    tvec.ptr< double >(0)[1] = 0.;
+    tvec.ptr< double >(0)[2] = distance;
+}
+
+/**
+ * @brief Project a synthetic marker
+ */
+static void projectMarker(Mat &img, Ptr<aruco::Dictionary> &dictionary, int id,
+                          vector< Point3f > markerObjPoints, Mat cameraMatrix, Mat rvec, Mat tvec,
+                          int markerBorder) {
+
+
+    // canonical image
+    Mat markerImg;
+    const int markerSizePixels = 100;
+    aruco::drawMarker(dictionary, id, markerSizePixels, markerImg, markerBorder);
+
+    // projected corners
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    vector< Point2f > corners;
+    projectPoints(markerObjPoints, rvec, tvec, cameraMatrix, distCoeffs, corners);
+
+    // get perspective transform
+    vector< Point2f > originalCorners;
+    originalCorners.push_back(Point2f(0, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, (float)markerSizePixels));
+    originalCorners.push_back(Point2f(0, (float)markerSizePixels));
+    Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+    // apply transformation
+    Mat aux;
+    const char borderValue = 127;
+    warpPerspective(markerImg, aux, transformation, img.size(), INTER_NEAREST, BORDER_CONSTANT,
+                    Scalar::all(borderValue));
+
+    // copy only not-border pixels
+    for(int y = 0; y < aux.rows; y++) {
+        for(int x = 0; x < aux.cols; x++) {
+            if(aux.at< unsigned char >(y, x) == borderValue) continue;
+            img.at< unsigned char >(y, x) = aux.at< unsigned char >(y, x);
+        }
+    }
+}
+
+
+/**
+ * @brief Get a synthetic image of GridBoard in perspective
+ */
+static Mat projectBoard(Ptr<aruco::GridBoard> &board, Mat cameraMatrix, double yaw, double pitch,
+                        double distance, Size imageSize, int markerBorder) {
+
+    Mat rvec, tvec;
+    getSyntheticRT(yaw, pitch, distance, rvec, tvec);
+
+    Mat img = Mat(imageSize, CV_8UC1, Scalar::all(255));
+    for(unsigned int m = 0; m < board->ids.size(); m++) {
+        projectMarker(img, board->dictionary, board->ids[m], board->objPoints[m], cameraMatrix, rvec,
+                      tvec, markerBorder);
+    }
+
+    return img;
+}
+
+
+
+/**
+ * @brief Check pose estimation of aruco board
+ */
+class CV_ArucoBoardPose : public cvtest::BaseTest {
+    public:
+    CV_ArucoBoardPose();
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoBoardPose::CV_ArucoBoardPose() {}
+
+
+void CV_ArucoBoardPose::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    Ptr<aruco::GridBoard> gridboard = aruco::GridBoard::create(3, 3, 0.02f, 0.005f, dictionary);
+    Ptr<aruco::Board> board = gridboard.staticCast<aruco::Board>();
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    // for different perspectives
+    for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
+        for(int yaw = 0; yaw < 360; yaw += 100) {
+            for(int pitch = 30; pitch <= 90; pitch += 50) {
+                for(unsigned int i = 0; i < gridboard->ids.size(); i++)
+                    gridboard->ids[i] = (iter + int(i)) % 250;
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // create synthetic image
+                Mat img = projectBoard(gridboard, cameraMatrix, deg2rad(pitch), deg2rad(yaw), distance,
+                                       imgSize, markerBorder);
+
+
+                vector< vector< Point2f > > corners;
+                vector< int > ids;
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 3;
+                params->markerBorderBits = markerBorder;
+                aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                if(ids.size() == 0) {
+                    ts->printf(cvtest::TS::LOG, "Marker detection failed in Board test");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                // estimate pose
+                Mat rvec, tvec;
+                aruco::estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec);
+
+                // check result
+                for(unsigned int i = 0; i < ids.size(); i++) {
+                    int foundIdx = -1;
+                    for(unsigned int j = 0; j < gridboard->ids.size(); j++) {
+                        if(gridboard->ids[j] == ids[i]) {
+                            foundIdx = int(j);
+                            break;
+                        }
+                    }
+
+                    if(foundIdx == -1) {
+                        ts->printf(cvtest::TS::LOG, "Marker detected with wrong ID in Board test");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+
+                    vector< Point2f > projectedCorners;
+                    projectPoints(gridboard->objPoints[foundIdx], rvec, tvec, cameraMatrix, distCoeffs,
+                                  projectedCorners);
+
+                    for(int c = 0; c < 4; c++) {
+                        double repError = cv::norm(projectedCorners[c] - corners[i][c]);  // TODO cvtest
+                        if(repError > 5.) {
+                            ts->printf(cvtest::TS::LOG, "Corner reprojection error too high");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+
+/**
+ * @brief Check refine strategy
+ */
+class CV_ArucoRefine : public cvtest::BaseTest {
+    public:
+    CV_ArucoRefine();
+
+    protected:
+    void run(int);
+};
+
+
+CV_ArucoRefine::CV_ArucoRefine() {}
+
+
+void CV_ArucoRefine::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    Ptr<aruco::GridBoard> gridboard = aruco::GridBoard::create(3, 3, 0.02f, 0.005f, dictionary);
+    Ptr<aruco::Board> board = gridboard.staticCast<aruco::Board>();
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    // for different perspectives
+    for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
+        for(int yaw = 0; yaw < 360; yaw += 100) {
+            for(int pitch = 30; pitch <= 90; pitch += 50) {
+                for(unsigned int i = 0; i < gridboard->ids.size(); i++)
+                    gridboard->ids[i] = (iter + int(i)) % 250;
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // create synthetic image
+                Mat img = projectBoard(gridboard, cameraMatrix, deg2rad(pitch), deg2rad(yaw), distance,
+                                       imgSize, markerBorder);
+
+
+                // detect markers
+                vector< vector< Point2f > > corners, rejected;
+                vector< int > ids;
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 3;
+                params->cornerRefinementMethod = aruco::CORNER_REFINE_SUBPIX;
+                params->markerBorderBits = markerBorder;
+                aruco::detectMarkers(img, dictionary, corners, ids, params, rejected);
+
+                // remove a marker from detection
+                int markersBeforeDelete = (int)ids.size();
+                if(markersBeforeDelete < 2) continue;
+
+                rejected.push_back(corners[0]);
+                corners.erase(corners.begin(), corners.begin() + 1);
+                ids.erase(ids.begin(), ids.begin() + 1);
+
+                // try to refind the erased marker
+                aruco::refineDetectedMarkers(img, board, corners, ids, rejected, cameraMatrix,
+                                             distCoeffs, 10, 3., true, noArray(), params);
+
+                // check result
+                if((int)ids.size() < markersBeforeDelete) {
+                    ts->printf(cvtest::TS::LOG, "Error in refine detected markers");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+            }
+        }
+    }
+}
+
+
+
+
+TEST(CV_ArucoBoardPose, accuracy) {
+    CV_ArucoBoardPose test;
+    test.safe_run();
+}
+
+TEST(CV_ArucoRefine, accuracy) {
+    CV_ArucoRefine test;
+    test.safe_run();
+}
+
+TEST(CV_ArucoBoardPose, CheckNegativeZ)
+{
+    double matrixData[9] = { -3.9062571886921410e+02, 0., 4.2350000000000000e+02,
+                              0., 3.9062571886921410e+02, 2.3950000000000000e+02,
+                              0., 0., 1 };
+    cv::Mat cameraMatrix = cv::Mat(3, 3, CV_64F, matrixData);
+
+    cv::Ptr<cv::aruco::Board> boardPtr(new cv::aruco::Board);
+    cv::aruco::Board& board = *boardPtr;
+    board.ids.push_back(0);
+    board.ids.push_back(1);
+
+    vector<cv::Point3f> pts3d;
+    pts3d.push_back(cv::Point3f(0.326198f, -0.030621f, 0.303620f));
+    pts3d.push_back(cv::Point3f(0.325340f, -0.100594f, 0.301862f));
+    pts3d.push_back(cv::Point3f(0.255859f, -0.099530f, 0.293416f));
+    pts3d.push_back(cv::Point3f(0.256717f, -0.029557f, 0.295174f));
+    board.objPoints.push_back(pts3d);
+    pts3d.clear();
+    pts3d.push_back(cv::Point3f(-0.033144f, -0.034819f, 0.245216f));
+    pts3d.push_back(cv::Point3f(-0.035507f, -0.104705f, 0.241987f));
+    pts3d.push_back(cv::Point3f(-0.105289f, -0.102120f, 0.237120f));
+    pts3d.push_back(cv::Point3f(-0.102926f, -0.032235f, 0.240349f));
+    board.objPoints.push_back(pts3d);
+
+    vector<vector<Point2f> > corners;
+    vector<Point2f> pts2d;
+    pts2d.push_back(cv::Point2f(37.7f, 203.3f));
+    pts2d.push_back(cv::Point2f(38.5f, 120.5f));
+    pts2d.push_back(cv::Point2f(105.5f, 115.8f));
+    pts2d.push_back(cv::Point2f(104.2f, 202.7f));
+    corners.push_back(pts2d);
+    pts2d.clear();
+    pts2d.push_back(cv::Point2f(476.0f, 184.2f));
+    pts2d.push_back(cv::Point2f(479.6f, 73.8f));
+    pts2d.push_back(cv::Point2f(590.9f, 77.0f));
+    pts2d.push_back(cv::Point2f(587.5f, 188.1f));
+    corners.push_back(pts2d);
+
+    Vec3d rvec, tvec;
+    int nUsed = cv::aruco::estimatePoseBoard(corners, board.ids, boardPtr, cameraMatrix, Mat(), rvec, tvec);
+    ASSERT_EQ(nUsed, 2);
+
+    cv::Matx33d rotm; cv::Point3d out;
+    cv::Rodrigues(rvec, rotm);
+    out = cv::Point3d(tvec) + rotm*Point3d(board.objPoints[0][0]);
+    ASSERT_GT(out.z, 0);
+
+    corners.clear(); pts2d.clear();
+    pts2d.push_back(cv::Point2f(38.4f, 204.5f));
+    pts2d.push_back(cv::Point2f(40.0f, 124.7f));
+    pts2d.push_back(cv::Point2f(102.0f, 119.1f));
+    pts2d.push_back(cv::Point2f(99.9f, 203.6f));
+    corners.push_back(pts2d);
+    pts2d.clear();
+    pts2d.push_back(cv::Point2f(476.0f, 184.3f));
+    pts2d.push_back(cv::Point2f(479.2f, 75.1f));
+    pts2d.push_back(cv::Point2f(588.7f, 79.2f));
+    pts2d.push_back(cv::Point2f(586.3f, 188.5f));
+    corners.push_back(pts2d);
+
+    nUsed = cv::aruco::estimatePoseBoard(corners, board.ids, boardPtr, cameraMatrix, Mat(), rvec, tvec, true);
+    ASSERT_EQ(nUsed, 2);
+
+    cv::Rodrigues(rvec, rotm);
+    out = cv::Point3d(tvec) + rotm*Point3d(board.objPoints[0][0]);
+    ASSERT_GT(out.z, 0);
+}
+
+}} // namespace

aruco_pose/vendor/aruco/test/test_charucodetection.cpp

@@ -0,0 +1,605 @@
+/*
+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 "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static double deg2rad(double deg) { return deg * CV_PI / 180.; }
+
+/**
+ * @brief Get rvec and tvec from yaw, pitch and distance
+ */
+static void getSyntheticRT(double yaw, double pitch, double distance, Mat &rvec, Mat &tvec) {
+
+    rvec = Mat(3, 1, CV_64FC1);
+    tvec = Mat(3, 1, CV_64FC1);
+
+    // Rvec
+    // first put the Z axis aiming to -X (like the camera axis system)
+    Mat rotZ(3, 1, CV_64FC1);
+    rotZ.ptr< double >(0)[0] = 0;
+    rotZ.ptr< double >(0)[1] = 0;
+    rotZ.ptr< double >(0)[2] = -0.5 * CV_PI;
+
+    Mat rotX(3, 1, CV_64FC1);
+    rotX.ptr< double >(0)[0] = 0.5 * CV_PI;
+    rotX.ptr< double >(0)[1] = 0;
+    rotX.ptr< double >(0)[2] = 0;
+
+    Mat camRvec, camTvec;
+    composeRT(rotZ, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotX, Mat(3, 1, CV_64FC1, Scalar::all(0)),
+              camRvec, camTvec);
+
+    // now pitch and yaw angles
+    Mat rotPitch(3, 1, CV_64FC1);
+    rotPitch.ptr< double >(0)[0] = 0;
+    rotPitch.ptr< double >(0)[1] = pitch;
+    rotPitch.ptr< double >(0)[2] = 0;
+
+    Mat rotYaw(3, 1, CV_64FC1);
+    rotYaw.ptr< double >(0)[0] = yaw;
+    rotYaw.ptr< double >(0)[1] = 0;
+    rotYaw.ptr< double >(0)[2] = 0;
+
+    composeRT(rotPitch, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotYaw,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // compose both rotations
+    composeRT(camRvec, Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec,
+              Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // Tvec, just move in z (camera) direction the specific distance
+    tvec.ptr< double >(0)[0] = 0.;
+    tvec.ptr< double >(0)[1] = 0.;
+    tvec.ptr< double >(0)[2] = distance;
+}
+
+/**
+ * @brief Project a synthetic marker
+ */
+static void projectMarker(Mat &img, Ptr<aruco::Dictionary> dictionary, int id,
+                          vector< Point3f > markerObjPoints, Mat cameraMatrix, Mat rvec, Mat tvec,
+                          int markerBorder) {
+
+
+    Mat markerImg;
+    const int markerSizePixels = 100;
+    aruco::drawMarker(dictionary, id, markerSizePixels, markerImg, markerBorder);
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    vector< Point2f > corners;
+    projectPoints(markerObjPoints, rvec, tvec, cameraMatrix, distCoeffs, corners);
+
+    vector< Point2f > originalCorners;
+    originalCorners.push_back(Point2f(0, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, (float)markerSizePixels));
+    originalCorners.push_back(Point2f(0, (float)markerSizePixels));
+
+    Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+    Mat aux;
+    const char borderValue = 127;
+    warpPerspective(markerImg, aux, transformation, img.size(), INTER_NEAREST, BORDER_CONSTANT,
+                    Scalar::all(borderValue));
+
+    // copy only not-border pixels
+    for(int y = 0; y < aux.rows; y++) {
+        for(int x = 0; x < aux.cols; x++) {
+            if(aux.at< unsigned char >(y, x) == borderValue) continue;
+            img.at< unsigned char >(y, x) = aux.at< unsigned char >(y, x);
+        }
+    }
+}
+
+/**
+ * @brief Get a synthetic image of Chessboard in perspective
+ */
+static Mat projectChessboard(int squaresX, int squaresY, float squareSize, Size imageSize,
+                             Mat cameraMatrix, Mat rvec, Mat tvec) {
+
+    Mat img(imageSize, CV_8UC1, Scalar::all(255));
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    for(int y = 0; y < squaresY; y++) {
+        float startY = float(y) * squareSize;
+        for(int x = 0; x < squaresX; x++) {
+            if(y % 2 != x % 2) continue;
+            float startX = float(x) * squareSize;
+
+            vector< Point3f > squareCorners;
+            squareCorners.push_back(Point3f(startX, startY, 0));
+            squareCorners.push_back(squareCorners[0] + Point3f(squareSize, 0, 0));
+            squareCorners.push_back(squareCorners[0] + Point3f(squareSize, squareSize, 0));
+            squareCorners.push_back(squareCorners[0] + Point3f(0, squareSize, 0));
+
+            vector< vector< Point2f > > projectedCorners;
+            projectedCorners.push_back(vector< Point2f >());
+            projectPoints(squareCorners, rvec, tvec, cameraMatrix, distCoeffs, projectedCorners[0]);
+
+            vector< vector< Point > > projectedCornersInt;
+            projectedCornersInt.push_back(vector< Point >());
+
+            for(int k = 0; k < 4; k++)
+                projectedCornersInt[0]
+                    .push_back(Point((int)projectedCorners[0][k].x, (int)projectedCorners[0][k].y));
+
+            fillPoly(img, projectedCornersInt, Scalar::all(0));
+        }
+    }
+
+    return img;
+}
+
+
+/**
+ * @brief Check pose estimation of charuco board
+ */
+static Mat projectCharucoBoard(Ptr<aruco::CharucoBoard> &board, Mat cameraMatrix, double yaw,
+                               double pitch, double distance, Size imageSize, int markerBorder,
+                               Mat &rvec, Mat &tvec) {
+
+    getSyntheticRT(yaw, pitch, distance, rvec, tvec);
+
+    // project markers
+    Mat img = Mat(imageSize, CV_8UC1, Scalar::all(255));
+    for(unsigned int m = 0; m < board->ids.size(); m++) {
+        projectMarker(img, board->dictionary, board->ids[m], board->objPoints[m], cameraMatrix, rvec,
+                      tvec, markerBorder);
+    }
+
+    // project chessboard
+    Mat chessboard =
+        projectChessboard(board->getChessboardSize().width, board->getChessboardSize().height,
+                          board->getSquareLength(), imageSize, cameraMatrix, rvec, tvec);
+
+    for(unsigned int i = 0; i < chessboard.total(); i++) {
+        if(chessboard.ptr< unsigned char >()[i] == 0) {
+            img.ptr< unsigned char >()[i] = 0;
+        }
+    }
+
+    return img;
+}
+
+
+
+
+/**
+ * @brief Check Charuco detection
+ */
+class CV_CharucoDetection : public cvtest::BaseTest {
+    public:
+    CV_CharucoDetection();
+
+    protected:
+    void run(int);
+};
+
+
+CV_CharucoDetection::CV_CharucoDetection() {}
+
+
+void CV_CharucoDetection::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.03f, 0.015f, dictionary);
+
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    // for different perspectives
+    for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
+        for(int yaw = 0; yaw < 360; yaw += 100) {
+            for(int pitch = 30; pitch <= 90; pitch += 50) {
+
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // create synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(pitch), deg2rad(yaw),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers
+                vector< vector< Point2f > > corners;
+                vector< int > ids;
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 3;
+                params->markerBorderBits = markerBorder;
+                aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                if(ids.size() == 0) {
+                    ts->printf(cvtest::TS::LOG, "Marker detection failed");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                // interpolate charuco corners
+                vector< Point2f > charucoCorners;
+                vector< int > charucoIds;
+
+                if(iter % 2 == 0) {
+                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                     charucoIds);
+                } else {
+                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                     charucoIds, cameraMatrix, distCoeffs);
+                }
+
+                // check results
+                vector< Point2f > projectedCharucoCorners;
+                projectPoints(board->chessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedCharucoCorners);
+
+                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+
+                    int currentId = charucoIds[i];
+
+                    if(currentId >= (int)board->chessboardCorners.size()) {
+                        ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+
+                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+
+/**
+ * @brief Check charuco pose estimation
+ */
+class CV_CharucoPoseEstimation : public cvtest::BaseTest {
+    public:
+    CV_CharucoPoseEstimation();
+
+    protected:
+    void run(int);
+};
+
+
+CV_CharucoPoseEstimation::CV_CharucoPoseEstimation() {}
+
+
+void CV_CharucoPoseEstimation::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    Ptr<aruco::CharucoBoard> board = aruco::CharucoBoard::create(4, 4, 0.03f, 0.015f, dictionary);
+
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    // for different perspectives
+    for(double distance = 0.2; distance <= 0.4; distance += 0.2) {
+        for(int yaw = 0; yaw < 360; yaw += 100) {
+            for(int pitch = 30; pitch <= 90; pitch += 50) {
+
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // get synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(pitch), deg2rad(yaw),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers
+                vector< vector< Point2f > > corners;
+                vector< int > ids;
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 3;
+                params->markerBorderBits = markerBorder;
+                aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                if(ids.size() == 0) {
+                    ts->printf(cvtest::TS::LOG, "Marker detection failed");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                // interpolate charuco corners
+                vector< Point2f > charucoCorners;
+                vector< int > charucoIds;
+
+                if(iter % 2 == 0) {
+                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                     charucoIds);
+                } else {
+                    aruco::interpolateCornersCharuco(corners, ids, img, board, charucoCorners,
+                                                     charucoIds, cameraMatrix, distCoeffs);
+                }
+
+                if(charucoIds.size() == 0) continue;
+
+                // estimate charuco pose
+                aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix,
+                                                distCoeffs, rvec, tvec);
+
+
+                // check result
+                vector< Point2f > projectedCharucoCorners;
+                projectPoints(board->chessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedCharucoCorners);
+
+                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+
+                    int currentId = charucoIds[i];
+
+                    if(currentId >= (int)board->chessboardCorners.size()) {
+                        ts->printf(cvtest::TS::LOG, "Invalid Charuco corner id");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+
+                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Charuco corner reprojection error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+/**
+ * @brief Check diamond detection
+ */
+class CV_CharucoDiamondDetection : public cvtest::BaseTest {
+    public:
+    CV_CharucoDiamondDetection();
+
+    protected:
+    void run(int);
+};
+
+
+CV_CharucoDiamondDetection::CV_CharucoDiamondDetection() {}
+
+
+void CV_CharucoDiamondDetection::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    float squareLength = 0.03f;
+    float markerLength = 0.015f;
+    Ptr<aruco::CharucoBoard> board =
+        aruco::CharucoBoard::create(3, 3, squareLength, markerLength, dictionary);
+
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    // for different perspectives
+    for(double distance = 0.3; distance <= 0.3; distance += 0.2) {
+        for(int yaw = 0; yaw < 360; yaw += 100) {
+            for(int pitch = 30; pitch <= 90; pitch += 30) {
+
+                int markerBorder = iter % 2 + 1;
+                for(int i = 0; i < 4; i++)
+                    board->ids[i] = 4 * iter + i;
+                iter++;
+
+                // get synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(pitch), deg2rad(yaw),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers
+                vector< vector< Point2f > > corners;
+                vector< int > ids;
+                Ptr<aruco::DetectorParameters> params = aruco::DetectorParameters::create();
+                params->minDistanceToBorder = 0;
+                params->markerBorderBits = markerBorder;
+                aruco::detectMarkers(img, dictionary, corners, ids, params);
+
+                if(ids.size() != 4) {
+                    ts->printf(cvtest::TS::LOG, "Not enough markers for diamond detection");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                // detect diamonds
+                vector< vector< Point2f > > diamondCorners;
+                vector< Vec4i > diamondIds;
+                aruco::detectCharucoDiamond(img, corners, ids, squareLength / markerLength,
+                                            diamondCorners, diamondIds, cameraMatrix, distCoeffs);
+
+                // check results
+                if(diamondIds.size() != 1) {
+                    ts->printf(cvtest::TS::LOG, "Diamond not detected correctly");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                for(int i = 0; i < 4; i++) {
+                    if(diamondIds[0][i] != board->ids[i]) {
+                        ts->printf(cvtest::TS::LOG, "Incorrect diamond ids");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+
+
+                vector< Point2f > projectedDiamondCorners;
+                projectPoints(board->chessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedDiamondCorners);
+
+                vector< Point2f > projectedDiamondCornersReorder(4);
+                projectedDiamondCornersReorder[0] = projectedDiamondCorners[2];
+                projectedDiamondCornersReorder[1] = projectedDiamondCorners[3];
+                projectedDiamondCornersReorder[2] = projectedDiamondCorners[1];
+                projectedDiamondCornersReorder[3] = projectedDiamondCorners[0];
+
+
+                for(unsigned int i = 0; i < 4; i++) {
+
+                    double repError = cv::norm(diamondCorners[0][i] - projectedDiamondCornersReorder[i]);  // TODO cvtest
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Diamond corner reprojection error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+
+                // estimate diamond pose
+                vector< Vec3d > estimatedRvec, estimatedTvec;
+                aruco::estimatePoseSingleMarkers(diamondCorners, squareLength, cameraMatrix,
+                                                 distCoeffs, estimatedRvec, estimatedTvec);
+
+                // check result
+                vector< Point2f > projectedDiamondCornersPose;
+                vector< Vec3f > diamondObjPoints(4);
+                diamondObjPoints[0] = Vec3f(-squareLength / 2.f, squareLength / 2.f, 0);
+                diamondObjPoints[1] = Vec3f(squareLength / 2.f, squareLength / 2.f, 0);
+                diamondObjPoints[2] = Vec3f(squareLength / 2.f, -squareLength / 2.f, 0);
+                diamondObjPoints[3] = Vec3f(-squareLength / 2.f, -squareLength / 2.f, 0);
+                projectPoints(diamondObjPoints, estimatedRvec[0], estimatedTvec[0], cameraMatrix,
+                              distCoeffs, projectedDiamondCornersPose);
+
+                for(unsigned int i = 0; i < 4; i++) {
+                    double repError = cv::norm(projectedDiamondCornersReorder[i] - projectedDiamondCornersPose[i]);  // TODO cvtest
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Charuco pose error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+* @brief Check charuco board creation
+*/
+class CV_CharucoBoardCreation : public cvtest::BaseTest {
+public:
+    CV_CharucoBoardCreation();
+
+protected:
+    void run(int);
+};
+
+CV_CharucoBoardCreation::CV_CharucoBoardCreation() {}
+
+void CV_CharucoBoardCreation::run(int)
+{
+    Ptr<aruco::Dictionary> dictionary = aruco::getPredefinedDictionary(aruco::DICT_5X5_250);
+    int n = 6;
+
+    float markerSizeFactor = 0.5f;
+
+    for (float squareSize_mm = 5.0f; squareSize_mm < 35.0f; squareSize_mm += 0.1f)
+    {
+        Ptr<aruco::CharucoBoard> board_meters = aruco::CharucoBoard::create(
+            n, n, squareSize_mm*1e-3f, squareSize_mm * markerSizeFactor * 1e-3f, dictionary);
+
+        Ptr<aruco::CharucoBoard> board_millimeters = aruco::CharucoBoard::create(
+            n, n, squareSize_mm, squareSize_mm * markerSizeFactor, dictionary);
+
+        for (size_t i = 0; i < board_meters->nearestMarkerIdx.size(); i++)
+        {
+            if (board_meters->nearestMarkerIdx[i].size() != board_millimeters->nearestMarkerIdx[i].size() ||
+                board_meters->nearestMarkerIdx[i][0] != board_millimeters->nearestMarkerIdx[i][0])
+            {
+                ts->printf(cvtest::TS::LOG,
+                    cv::format("Charuco board topology is sensitive to scale with squareSize=%.1f\n",
+                        squareSize_mm).c_str());
+                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                break;
+            }
+        }
+    }
+}
+
+
+TEST(CV_CharucoDetection, accuracy) {
+    CV_CharucoDetection test;
+    test.safe_run();
+}
+
+TEST(CV_CharucoPoseEstimation, accuracy) {
+    CV_CharucoPoseEstimation test;
+    test.safe_run();
+}
+
+TEST(CV_CharucoDiamondDetection, accuracy) {
+    CV_CharucoDiamondDetection test;
+    test.safe_run();
+}
+
+TEST(CV_CharucoBoardCreation, accuracy) {
+    CV_CharucoBoardCreation test;
+    test.safe_run();
+}
+
+}} // namespace

aruco_pose/vendor/aruco/test/test_main.cpp

@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

aruco_pose/vendor/aruco/test/test_misc.cpp

@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(CV_ArucoDrawMarker, regression_1226)
+{
+    int squares_x = 7;
+    int squares_y = 5;
+    int bwidth = 1600;
+    int bheight = 1200;
+
+    cv::Ptr<cv::aruco::Dictionary> dict = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(squares_x, squares_y, 1.0, 0.75, dict);
+    cv::Size sz(bwidth, bheight);
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+    {
+        board->draw(sz, mat, 0, 1);
+    });
+}
+
+}} // namespace

aruco_pose/vendor/aruco/test/test_precomp.hpp

@@ -0,0 +1,13 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/aruco.hpp"
+#include <opencv2/aruco/charuco.hpp>
+
+#endif

aruco_pose/vendor/aruco/tutorials/aruco_board_detection/aruco_board_detection.markdown

@@ -0,0 +1,273 @@
+Detection of ArUco Boards {#tutorial_aruco_board_detection}
+==============================
+
+An ArUco Board is a set of markers that acts like a single marker in the sense that it provides a
+single pose for the camera.
+
+The most popular board is the one with all the markers in the same plane, since it can be easily printed:
+
+![](images/gboriginal.png)
+
+However, boards are not limited to this arrangement and can represent any 2d or 3d layout.
+
+The difference between a Board and a set of independent markers is that the relative position between
+the markers in the Board is known a priori. This allows that the corners of all the markers can be used for
+estimating the pose of the camera respect to the whole Board.
+
+When you use a set of independent markers, you can estimate the pose for each marker individually,
+since you dont know the relative position of the markers in the environment.
+
+The main benefits of using Boards are:
+
+- The pose estimation is much more versatile. Only some markers are necessary to perform pose estimation.
+Thus, the pose can be calculated even in the presence of occlusions or partial views.
+- The obtained pose is usually more accurate since a higher amount of point correspondences (marker
+corners) are employed.
+
+The aruco module allows the use of Boards. The main class is the ```cv::aruco::Board``` class which defines the Board layout:
+
+@code{.cpp}
+    class  Board {
+    public:
+        std::vector<std::vector<cv::Point3f> > objPoints;
+        cv::Ptr<cv::aruco::Dictionary> dictionary;
+        std::vector<int> ids;
+    };
+@endcode
+
+A object of type ```Board``` has three parameters:
+- The ```objPoints``` structure is the list of corner positions in the 3d Board reference system, i.e. its layout.
+For each marker, its four corners are stored in the standard order, i.e. in clockwise order and starting
+with the top left corner.
+- The ```dictionary``` parameter indicates to which marker dictionary the Board markers belong to.
+- Finally, the ```ids``` structure indicates the identifiers of each of the markers in ```objPoints``` respect to the specified  ```dictionary```.
+
+
+Board Detection
+-----
+
+A Board detection is similar to the standard marker detection. The only difference is in the pose estimation step.
+In fact, to use marker boards, a standard marker detection should be done before estimating the Board pose.
+
+The aruco module provides a specific function, ```estimatePoseBoard()```, to perform pose estimation for boards:
+
+@code{.cpp}
+    cv::Mat inputImage;
+    // camera parameters are read from somewhere
+    cv::Mat cameraMatrix, distCoeffs;
+    readCameraParameters(cameraMatrix, distCoeffs);
+    // assume we have a function to create the board object
+    cv::Ptr<cv::aruco::Board> board = cv::aruco::Board::create();
+    ...
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> markerCorners;
+    cv::aruco::detectMarkers(inputImage, board.dictionary, markerCorners, markerIds);
+    // if at least one marker detected
+    if(markerIds.size() > 0) {
+        cv::Vec3d rvec, tvec;
+        int valid = cv::aruco::estimatePoseBoard(markerCorners, markerIds, board, cameraMatrix, distCoeffs, rvec, tvec);
+    }
+@endcode
+
+The parameters of estimatePoseBoard are:
+
+- ```markerCorners``` and ```markerIds```: structures of detected markers from ```detectMarkers()``` function.
+- ```board```: the ```Board``` object that defines the board layout and its ids
+- ```cameraMatrix``` and ```distCoeffs```: camera calibration parameters necessary for pose estimation.
+- ```rvec``` and ```tvec```: estimated pose of the Board. If not empty then treated as initial guess.
+- The function returns the total number of markers employed for estimating the board pose. Note that not all the
+ markers provided in ```markerCorners``` and ```markerIds``` should be used, since only the markers whose ids are
+listed in the ```Board::ids``` structure are considered.
+
+The ```drawAxis()``` function can be used to check the obtained pose. For instance:
+
+![Board with axis](images/gbmarkersaxis.png)
+
+And this is another example with the board partially occluded:
+
+![Board with occlusions](images/gbocclusion.png)
+
+As it can be observed, although some markers have not been detected, the Board pose can still be estimated from the rest of markers.
+
+Grid Board
+-----
+
+Creating the ```Board``` object requires specifying the corner positions for each marker in the environment.
+However, in many cases, the board will be just a set of markers in the same plane and in a grid layout,
+so it can be easily printed and used.
+
+Fortunately, the aruco module provides the basic functionality to create and print these types of markers
+easily.
+
+The ```GridBoard``` class is a specialized class that inherits from the ```Board``` class and which represents a Board
+with all the markers in the same plane and in a grid layout, as in the following image:
+
+![Image with aruco board](images/gboriginal.png)
+
+Concretely, the coordinate system in a Grid Board is positioned in the board plane, centered in the bottom left
+corner of the board and with the Z pointing out, like in the following image (X:red, Y:green, Z:blue):
+
+![Board with axis](images/gbaxis.png)
+
+A ```GridBoard``` object can be defined using the following parameters:
+
+- Number of markers in the X direction.
+- Number of markers in the Y direction.
+- Lenght of the marker side.
+- Length of the marker separation.
+- The dictionary of the markers.
+- Ids of all the markers (X*Y markers).
+
+This object can be easily created from these parameters using the ```cv::aruco::GridBoard::create()``` static function:
+
+@code{.cpp}
+    cv::aruco::GridBoard board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
+@endcode
+
+- The first and second parameters are the number of markers in the X and Y direction respectively.
+- The third and fourth parameters are the marker length and the marker separation respectively. They can be provided
+in any unit, having in mind that the estimated pose for this board will be measured in the same units (in general, meters are used).
+- Finally, the dictionary of the markers is provided.
+
+So, this board will be composed by 5x7=35 markers. The ids of each of the markers are assigned, by default, in ascending
+order starting on 0, so they will be 0, 1, 2, ..., 34. This can be easily customized by accessing to the ids vector
+through ```board.ids```, like in the ```Board``` parent class.
+
+After creating a Grid Board, we probably want to print it and use it. A function to generate the image
+of a ```GridBoard``` is provided in ```cv::aruco::GridBoard::draw()```. For example:
+
+@code{.cpp}
+    cv::Ptr<cv::aruco::GridBoard> board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
+    cv::Mat boardImage;
+    board->draw( cv::Size(600, 500), boardImage, 10, 1 );
+@endcode
+
+- The first parameter is the size of the output image in pixels. In this case 600x500 pixels. If this is not proportional
+to the board dimensions, it will be centered on the image.
+- ```boardImage```: the output image with the board.
+- The third parameter is the (optional) margin in pixels, so none of the markers are touching the image border.
+In this case the margin is 10.
+- Finally, the size of the marker border, similarly to ```drawMarker()``` function. The default value is 1.
+
+The output image will be something like this:
+
+![](images/board.jpg)
+
+A full working example of board creation is included in the ```create_board.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "_output path_/aboard.png" -w=5 -h=7 -l=100 -s=10 -d=10
+@endcode
+
+Finally, a full example of board detection:
+
+@code{.cpp}
+    cv::VideoCapture inputVideo;
+    inputVideo.open(0);
+
+    cv::Mat cameraMatrix, distCoeffs;
+    // camera parameters are read from somewhere
+    readCameraParameters(cameraMatrix, distCoeffs);
+
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::GridBoard> board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
+
+    while (inputVideo.grab()) {
+        cv::Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        image.copyTo(imageCopy);
+
+        std::vector<int> ids;
+        std::vector<std::vector<cv::Point2f> > corners;
+        cv::aruco::detectMarkers(image, dictionary, corners, ids);
+
+        // if at least one marker detected
+        if (ids.size() > 0) {
+            cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
+
+            cv::Vec3d rvec, tvec;
+            int valid = estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec);
+
+            // if at least one board marker detected
+            if(valid > 0)
+                cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvec, tvec, 0.1);
+        }
+
+        cv::imshow("out", imageCopy);
+        char key = (char) cv::waitKey(waitTime);
+        if (key == 27)
+            break;
+    }
+@endcode
+
+Sample video:
+
+@htmlonly
+<iframe width="420" height="315" src="https://www.youtube.com/embed/Q1HlJEjW_j0" frameborder="0" allowfullscreen></iframe>
+@endhtmlonly
+
+A full working example is included in the ```detect_board.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_path_"/calib.txt" "_path_/aboard.png" -w=5 -h=7 -l=100 -s=10 -d=10
+@endcode
+
+
+
+Refine marker detection
+-----
+
+ArUco boards can also be used to improve the detection of markers. If we have detected a subset of the markers
+that belongs to the board, we can use these markers and the board layout information to try to find the
+markers that have not been previously detected.
+
+This can be done using the ```refineDetectedMarkers()``` function, which should be called
+after calling ```detectMarkers()```.
+
+The main parameters of this function are the original image where markers were detected, the Board object,
+the detected marker corners, the detected marker ids and the rejected marker corners.
+
+The rejected corners can be obtained from the ```detectMarkers()``` function and are also known as marker
+candidates. This candidates are square shapes that have been found in the original image but have failed
+to pass the identification step (i.e. their inner codification presents too many errors) and thus they
+have not been recognized as markers.
+
+However, these candidates are sometimes actual markers that have not been correctly identified due to high
+noise in the image, very low resolution or other related problems that affect to the binary code extraction.
+The ```refineDetectedMarkers()``` function finds correspondences between these candidates and the missing
+markers of the board. This search is based on two parameters:
+
+- Distance between the candidate and the projection of the missing marker. To obtain these projections,
+it is necessary to have detected at least one marker of the board. The projections are obtained using the
+camera parameters (camera matrix and distortion coefficients) if they are provided. If not, the projections
+are obtained from local homography and only planar board are allowed (i.e. the Z coordinate of all the
+marker corners should be the same). The ```minRepDistance``` parameter in ```refineDetectedMarkers()```
+determines the minimum euclidean distance between the candidate corners and the projected marker corners
+(default value 10).
+
+- Binary codification. If a candidate surpasses the minimum distance condition, its internal bits
+are analyzed again to determine if it is actually the projected marker or not. However, in this case,
+the condition is not so strong and the number of allowed erroneous bits can be higher. This is indicated
+in the ```errorCorrectionRate``` parameter (default value 3.0). If a negative value is provided, the
+internal bits are not analyzed at all and only the corner distances are evaluated.
+
+This is an example of using the  ```refineDetectedMarkers()``` function:
+
+@code{.cpp}
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::GridBoard> board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> markerCorners, rejectedCandidates;
+    cv::aruco::detectMarkers(inputImage, dictionary, markerCorners, markerIds, cv::aruco::DetectorParameters(), rejectedCandidates);
+
+    cv::aruco::refineDetectedMarkersinputImage, board, markerCorners, markerIds, rejectedCandidates);
+    // After calling this function, if any new marker has been detected it will be removed from rejectedCandidates and included
+    // at the end of markerCorners and markerIds
+@endcode
+
+It must also be noted that, in some cases, if the number of detected markers in the first place is too low (for instance only
+1 or 2 markers), the projections of the missing markers can be of bad quality, producing erroneous correspondences.
+
+See module samples for a more detailed implementation.

aruco_pose/vendor/aruco/tutorials/aruco_calibration/aruco_calibration.markdown

@@ -0,0 +1,112 @@
+Calibration with ArUco and ChArUco {#tutorial_aruco_calibration}
+==============================
+
+The ArUco module can also be used to calibrate a camera. Camera calibration consists in obtaining the
+camera intrinsic parameters and distortion coefficients. This parameters remain fixed unless the camera
+optic is modified, thus camera calibration only need to be done once.
+
+Camera calibration is usually performed using the OpenCV ```calibrateCamera()``` function. This function
+requires some correspondences between environment points and their projection in the camera image from
+different viewpoints. In general, these correspondences are obtained from the corners of chessboard
+patterns. See ```calibrateCamera()``` function documentation or the OpenCV calibration tutorial for
+more detailed information.
+
+Using the ArUco module, calibration can be performed based on ArUco markers corners or ChArUco corners.
+Calibrating using ArUco is much more versatile than using traditional chessboard patterns, since it
+allows occlusions or partial views.
+
+As it can be stated, calibration can be done using both, marker corners or ChArUco corners. However,
+it is highly recommended using the ChArUco corners approach since the provided corners are much
+more accurate in comparison to the marker corners. Calibration using a standard Board should only be
+employed in those scenarios where the ChArUco boards cannot be employed because of any kind of restriction.
+
+Calibration with ChArUco Boards
+------
+
+To calibrate using a ChArUco board, it is necessary to detect the board from different viewpoints, in the
+same way that the standard calibration does with the traditional chessboard pattern. However, due to the
+benefits of using ChArUco, occlusions and partial views are allowed, and not all the corners need to be
+visible in all the viewpoints.
+
+![ChArUco calibration viewpoints](images/charucocalibration.png)
+
+The function to calibrate is ```calibrateCameraCharuco()```. Example:
+
+@code{.cpp}
+    cv::Ptr<aruco::CharucoBoard> board = ... // create charuco board
+    cv::Size imgSize = ... // camera image size
+
+    std::vector<std::vector<cv::Point2f>> allCharucoCorners;
+    std::vector<std::vector<int>> allCharucoIds;
+    // Detect charuco board from several viewpoints and fill allCharucoCorners and allCharucoIds
+    ...
+    ...
+
+    // After capturing in several viewpoints, start calibration
+    cv::Mat cameraMatrix, distCoeffs;
+    std::vector<cv::Mat> rvecs, tvecs;
+    int calibrationFlags = ... // Set calibration flags (same than in calibrateCamera() function)
+
+    double repError = cv::aruco::calibrateCameraCharuco(allCharucoCorners, allCharucoIds, board, imgSize, cameraMatrix, distCoeffs, rvecs, tvecs, calibrationFlags);
+@endcode
+
+The ChArUco corners and ChArUco identifiers captured on each viewpoint are stored in the vectors ```allCharucoCorners``` and ```allCharucoIds```, one element per viewpoint.
+
+The ```calibrateCameraCharuco()``` function will fill the ```cameraMatrix``` and ```distCoeffs``` arrays with the camera calibration parameters. It will return the reprojection
+error obtained from the calibration. The elements in ```rvecs``` and ```tvecs``` will be filled with the estimated pose of the camera (respect to the ChArUco board)
+in each of the viewpoints.
+
+Finally, the ```calibrationFlags``` parameter determines some of the options for the calibration. Its format is equivalent to the flags parameter in the OpenCV
+```calibrateCamera()``` function.
+
+A full working example is included in the ```calibrate_camera_charuco.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    _output path_" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
+@endcode
+
+
+
+Calibration with ArUco Boards
+------
+
+As it has been stated, it is recommended the use of ChAruco boards instead of ArUco boards for camera calibration, since
+ChArUco corners are more accurate than marker corners. However, in some special cases it must be required to use calibration
+based on ArUco boards. For these cases, the ```calibrateCameraAruco()``` function is provided. As in the previous case, it
+requires the detections of an ArUco board from different viewpoints.
+
+![ArUco calibration viewpoints](images/arucocalibration.png)
+
+Example of ```calibrateCameraAruco()``` use:
+
+@code{.cpp}
+    cv::Ptr<aruco::Board> board = ... // create aruco board
+    cv::Size imgSize = ... // camera image size
+
+    std::vector<std::vector<cv::Point2f>> allCornersConcatenated;
+    std::vector<int> allIdsConcatenated;
+    std::vector<int> markerCounterPerFrame;
+    // Detect aruco board from several viewpoints and fill allCornersConcatenated, allIdsConcatenated and markerCounterPerFrame
+    ...
+    ...
+
+    // After capturing in several viewpoints, start calibration
+    cv::Mat cameraMatrix, distCoeffs;
+    std::vector<cv::Mat> rvecs, tvecs;
+    int calibrationFlags = ... // Set calibration flags (same than in calibrateCamera() function)
+
+    double repError = cv::aruco::calibrateCameraAruco(allCornersConcatenated, allIdsConcatenated, markerCounterPerFrame, board, imgSize, cameraMatrix, distCoeffs, rvecs, tvecs, calibrationFlags);
+@endcode
+
+In this case, and contrary to the ```calibrateCameraCharuco()``` function, the detected markers on each viewpoint are concatenated in the arrays ```allCornersConcatenated``` and
+```allCornersConcatenated``` (the first two parameters). The third parameter, the array ```markerCounterPerFrame```, indicates the number of marker detected on each viewpoint.
+The rest of parameters are the same than in ```calibrateCameraCharuco()```, except the board layout object which does not need to be a ```CharucoBoard``` object, it can be
+any ```Board``` object.
+
+A full working example is included in the ```calibrate_camera.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "_path_/calib.txt" -w=5 -h=7 -l=100 -s=10 -d=10
+@endcode

aruco_pose/vendor/aruco/tutorials/aruco_detection/aruco_detection.markdown

@@ -0,0 +1,737 @@
+Detection of ArUco Markers {#tutorial_aruco_detection}
+==============================
+
+Pose estimation is of great importance in many computer vision applications: robot navigation,
+augmented reality, and many more. This process is based on finding correspondences between points in
+the real environment and their 2d image projection. This is usually a difficult step, and thus it is
+common the use of synthetic or fiducial markers to make it easier.
+
+One of the most popular approach is the use of binary square fiducial markers. The main benefit
+of these markers is that a single marker provides enough correspondences (its four corners)
+to obtain the camera pose. Also, the inner binary codification makes them specially robust, allowing
+the possibility of applying error detection and correction techniques.
+
+The aruco module is based on the [ArUco library](http://www.uco.es/investiga/grupos/ava/node/26),
+a popular library for detection of square fiducial markers developed by Rafael Muñoz and Sergio Garrido:
+
+> S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+> "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+> Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+
+The aruco functionalities are included in:
+@code{.cpp}
+    #include <opencv2/aruco.hpp>
+@endcode
+
+
+Markers and Dictionaries
+------
+
+An ArUco marker is a synthetic square marker composed by a wide black border and a inner binary
+matrix which determines its identifier (id). The black border facilitates its fast detection in the
+image and the binary codification allows its identification and the application of error detection
+and correction techniques. The marker size determines the size of the internal matrix. For instance
+a marker size of 4x4 is composed by 16 bits.
+
+Some examples of ArUco markers:
+
+![Example of markers images](images/markers.jpg)
+
+It must be noted that a marker can be found rotated in the environment, however, the detection
+process needs to be able to determine its original rotation, so that each corner is identified
+unequivocally. This is also done based on the binary codification.
+
+A dictionary of markers is a set of markers that are considered in an specific application. It is
+simply the list of binary codifications of each of its markers.
+
+The main properties of a dictionary are the dictionary size and the marker size.
+
+- The dictionary size is the number of markers that composed the dictionary.
+- The marker size is the size of those markers (the number of bits).
+
+The aruco module includes some predefined dictionaries covering a range of different dictionary
+sizes and marker sizes.
+
+One may think that the marker id is the number obtained from converting the binary codification to
+a decimal base number. However, this is not possible since for high marker sizes the number of bits
+is too high and managing so huge numbers is not practical. Instead, a marker id is simply
+the marker index inside the dictionary it belongs to. For instance, the first 5 markers inside a
+dictionary has the ids: 0, 1, 2, 3 and 4.
+
+More information about dictionaries is provided in the "Selecting a dictionary" section.
+
+
+Marker Creation
+------
+
+Before their detection, markers need to be printed in order to be placed in the environment.
+Marker images can be generated using the ```drawMarker()``` function.
+
+For example, lets analyze the following call:
+
+@code{.cpp}
+    cv::Mat markerImage;
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::aruco::drawMarker(dictionary, 23, 200, markerImage, 1);
+@endcode
+
+First, the ```Dictionary``` object is created by choosing one of the predefined dictionaries in the aruco module.
+Concretely, this dictionary is composed by 250 markers and a marker size of 6x6 bits (```DICT_6X6_250```).
+
+The parameters of ```drawMarker``` are:
+
+- The first parameter is the ```Dictionary``` object previously created.
+- The second parameter is the marker id, in this case the marker 23 of the dictionary ```DICT_6X6_250```.
+Note that each dictionary is composed by a different number of markers. In this case, the valid ids
+go from 0 to 249. Any specific id out of the valid range will produce an exception.
+- The third parameter, 200, is the size of the output marker image. In this case, the output image
+will have a size of 200x200 pixels. Note that this parameter should be large enough to store the
+number of bits for the specific dictionary. So, for instance, you cannot generate an image of
+5x5 pixels for a marker size of 6x6 bits (and that is without considering the marker border).
+Furthermore, to avoid deformations, this parameter should be proportional to the number of bits +
+border size, or at least much higher than the marker size (like 200 in the example), so that
+deformations are insignificant.
+- The forth parameter is the output image.
+- Finally, the last parameter is an optional parameter to specify the width of the marker black
+border. The size is specified proportional to the number of bits. For instance a value of 2 means
+that the border will have a width equivalent to the size of two internal bits. The default value
+is 1.
+
+The generated image is:
+
+![Generated marker](images/marker23.jpg)
+
+A full working example is included in the ```create_marker.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "/Users/Sarthak/Dropbox/OpenCV_GSoC/marker.png" -d=10 -id=1
+@endcode
+
+Marker Detection
+------
+
+Given an image where some ArUco markers are visible, the detection process has to return a list of
+detected markers. Each detected marker includes:
+
+- The position of its four corners in the image (in their original order).
+- The id of the marker.
+
+The marker detection process is comprised by two main steps:
+
+1. Detection of marker candidates. In this step the image is analyzed in order to find square shapes
+that are candidates to be markers. It begins with an adaptive thresholding to segment the markers,
+then contours are extracted from the thresholded image and those that are not convex or do not
+approximate to a square shape are discarded. Some extra filtering are also applied (removing
+too small or too big contours, removing contours too close to each other, etc).
+
+2. After the candidate detection, it is necessary to determine if they are actually markers by
+analyzing their inner codification. This step starts by extracting the marker bits of each marker.
+To do so, first, perspective transformation is applied to obtain the marker in its canonical form. Then, the
+canonical image is thresholded using Otsu to separate white and black bits. The image is divided in
+different cells according to the marker size and the border size and the amount of black or white
+pixels on each cell is counted to determine if it is a white or a black bit. Finally, the bits
+are analyzed to determine if the marker belongs to the specific dictionary and error correction
+techniques are employed when necessary.
+
+
+Consider the following image:
+
+![Original image with markers](images/singlemarkersoriginal.png)
+
+These are the detected markers (in green):
+
+![Image with detected markers](images/singlemarkersdetection.png)
+
+And these are the marker candidates that have been rejected during the identification step (in pink):
+
+![Image with rejected candidates](images/singlemarkersrejected.png)
+
+In the aruco module, the detection is performed in the ```detectMarkers()``` function. This function is
+the most important in the module, since all the rest of functionalities are based on the
+previous detected markers returned by ```detectMarkers()```.
+
+An example of marker detection:
+
+@code{.cpp}
+    cv::Mat inputImage;
+    ...
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> markerCorners, rejectedCandidates;
+    cv::Ptr<cv::aruco::DetectorParameters> parameters;
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::aruco::detectMarkers(inputImage, dictionary, markerCorners, markerIds, parameters, rejectedCandidates);
+@endcode
+
+The parameters of ```detectMarkers``` are:
+
+- The first parameter is the image where the markers are going to be detected.
+- The second parameter is the dictionary object, in this case one of the predefined dictionaries (```DICT_6X6_250```).
+- The detected markers are stored in the ```markerCorners``` and ```markerIds``` structures:
+    - ```markerCorners``` is the list of corners of the detected markers. For each marker, its four
+    corners are returned in their original order (which is clockwise starting with top left). So, the first corner is the top left corner, followed by the top right, bottom right and bottom left.
+    - ```markerIds``` is the list of ids of each of the detected markers in ```markerCorners```.
+    Note that the returned ```markerCorners``` and ```markerIds``` vectors have the same sizes.
+- The fourth parameter is the object of type ```DetectionParameters```. This object includes all the
+parameters that can be customized during the detection process. This parameters are commented in
+detail in the next section.
+- The final parameter, ```rejectedCandidates```, is a returned list of marker candidates, i.e. those
+squares that have been found but they do not present a valid codification. Each candidate is also
+defined by its four corners, and its format is the same than the ```markerCorners``` parameter. This
+parameter can be omitted and is only useful for debugging purposes and for 'refind' strategies (see ```refineDetectedMarkers()``` ).
+
+
+The next thing you probably want to do after ```detectMarkers()``` is checking that your markers have
+been correctly detected. Fortunately, the aruco module provides a function to draw the detected
+markers in the input image, this function is ```drawDetectedMarkers()```. For example:
+
+@code{.cpp}
+    cv::Mat outputImage
+    cv::aruco::drawDetectedMarkers(image, markerCorners, markerIds);
+@endcode
+
+- ```image``` is the input/output image where the markers will be drawn (it will normally be the same image where the markers were detected).
+- ```markerCorners``` and ```markerIds``` are the structures of the detected markers in the same format
+provided by the ```detectMarkers()``` function.
+
+![Image with detected markers](images/singlemarkersdetection.png)
+
+Note that this function is only provided for visualization and its use can be perfectly omitted.
+
+With these two functions we can create a basic marker detection loop to detect markers from our
+camera:
+
+@code{.cpp}
+    cv::VideoCapture inputVideo;
+    inputVideo.open(0);
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    while (inputVideo.grab()) {
+        cv::Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        image.copyTo(imageCopy);
+
+        std::vector<int> ids;
+        std::vector<std::vector<cv::Point2f> > corners;
+        cv::aruco::detectMarkers(image, dictionary, corners, ids);
+
+        // if at least one marker detected
+        if (ids.size() > 0)
+            cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
+
+        cv::imshow("out", imageCopy);
+        char key = (char) cv::waitKey(waitTime);
+        if (key == 27)
+            break;
+    }
+@endcode
+
+Note that some of the optional parameters have been omitted, like the detection parameter object or the
+output vector of rejected candidates.
+
+A full working example is included in the ```detect_markers.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_path_/calib.txt" -d=10
+@endcode
+
+
+
+Pose Estimation
+------
+
+The next thing you probably want to do after detecting the markers is to obtain the camera pose from them.
+
+To perform camera pose estimation you need to know the calibration parameters of your camera. This is
+the camera matrix and distortion coefficients. If you do not know how to calibrate your camera, you can
+take a look to the ```calibrateCamera()``` function and the Calibration tutorial of OpenCV. You can also calibrate your camera using the aruco module
+as it is explained in the Calibration with aruco tutorial. Note that this only need to be done once unless the
+camera optics are modified (for instance changing its focus).
+
+At the end, what you get after the calibration is the camera matrix: a matrix of 3x3 elements with the
+focal distances and the camera center coordinates (a.k.a intrinsic parameters), and the distortion
+coefficients: a vector of 5 elements or more that models the distortion produced by your camera.
+
+When you estimate the pose with ArUco markers, you can estimate the pose of each marker individually.
+If you want to estimate one pose from a set of markers, what you want to use is aruco Boards (see ArUco
+Boards tutorial).
+
+The camera pose respect to a marker is the 3d transformation from the marker coordinate system to the
+camera coordinate system. It is specified by a rotation and a translation vector (see ```solvePnP()``` function for more
+information).
+
+The aruco module provides a function to estimate the poses of all the detected markers:
+
+@code{.cpp}
+    cv::Mat cameraMatrix, distCoeffs;
+    ...
+    std::vector<cv::Vec3d> rvecs, tvecs;
+    cv::aruco::estimatePoseSingleMarkers(corners, 0.05, cameraMatrix, distCoeffs, rvecs, tvecs);
+@endcode
+
+- The ```corners``` parameter is the vector of marker corners returned by the ```detectMarkers()``` function.
+- The second parameter is the size of the marker side in meters or in any other unit. Note that the
+translation vectors of the estimated poses will be in the same unit
+- ```cameraMatrix``` and ```distCoeffs``` are the camera calibration parameters that need to be known a priori.
+- ```rvecs``` and ```tvecs``` are the rotation and translation vectors respectively, for each of the markers
+in corners.
+
+The marker coordinate system that is assumed by this function is placed at the center of the marker
+with the Z axis pointing out, as in the following image. Axis-color correspondences are X:red, Y:green, Z:blue.
+
+![Image with axis drawn](images/singlemarkersaxis.png)
+
+The aruco module provides a function to draw the axis as in the image above, so pose estimation can be
+checked:
+
+@code{.cpp}
+    cv::aruco::drawAxis(image, cameraMatrix, distCoeffs, rvec, tvec, 0.1);
+@endcode
+
+- ```image``` is the input/output image where the axis will be drawn (it will normally be the same image where the markers were detected).
+- ```cameraMatrix``` and ```distCoeffs``` are the camera calibration parameters.
+- ```rvec``` and ```tvec``` are the pose parameters whose axis want to be drawn.
+- The last parameter is the length of the axis, in the same unit that tvec (usually meters)
+
+A basic full example for pose estimation from single markers:
+
+@code{.cpp}
+    cv::VideoCapture inputVideo;
+    inputVideo.open(0);
+
+    cv::Mat cameraMatrix, distCoeffs;
+    // camera parameters are read from somewhere
+    readCameraParameters(cameraMatrix, distCoeffs);
+
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+
+    while (inputVideo.grab()) {
+        cv::Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        image.copyTo(imageCopy);
+
+        std::vector<int> ids;
+        std::vector<std::vector<cv::Point2f>> corners;
+        cv::aruco::detectMarkers(image, dictionary, corners, ids);
+
+        // if at least one marker detected
+        if (ids.size() > 0) {
+            cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
+
+            std::vector<cv::Vec3d> rvecs, tvecs;
+            cv::aruco::estimatePoseSingleMarkers(corners, 0.05, cameraMatrix, distCoeffs, rvecs, tvecs);
+            // draw axis for each marker
+            for(int i=0; i<ids.size(); i++)
+                cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvecs[i], tvecs[i], 0.1);
+        }
+
+        cv::imshow("out", imageCopy);
+        char key = (char) cv::waitKey(waitTime);
+        if (key == 27)
+            break;
+    }
+@endcode
+
+Sample video:
+
+@htmlonly
+<iframe width="420" height="315" src="https://www.youtube.com/embed/IsXWrcB_Hvs" frameborder="0" allowfullscreen></iframe>
+@endhtmlonly
+
+A full working example is included in the ```detect_markers.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_path_/calib.txt" -d=10
+@endcode
+
+
+
+Selecting a dictionary
+------
+
+The aruco module provides the ```Dictionary``` class to represent a dictionary of markers.
+
+Apart of the marker size and the number of markers in the dictionary, there is another important dictionary
+parameter, the inter-marker distance. The inter-marker distance is the minimum distance among its markers
+and it determines the error detection and correction capabilities of the dictionary.
+
+In general, lower dictionary sizes and higher marker sizes increase the inter-marker distance and
+vice-versa. However, the detection of markers with higher sizes is more complex, due to the higher
+amount of bits that need to be extracted from the image.
+
+For instance, if you need only 10 markers in your application, it is better to use a dictionary only
+composed by those 10 markers than using one dictionary composed by 1000 markers. The reason is that
+the dictionary composed by 10 markers will have a higher inter-marker distance and, thus, it will be
+more robust to errors.
+
+As a consequence, the aruco module includes several ways to select your dictionary of markers, so that
+you can increase your system robustness:
+
+- Predefined dictionaries:
+
+This is the easiest way to select a dictionary. The aruco module includes a set of predefined dictionaries
+ of a variety of marker sizes and number of markers. For instance:
+
+@code{.cpp}
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+@endcode
+
+DICT_6X6_250 is an example of predefined dictionary of markers with 6x6 bits and a total of 250
+markers.
+
+From all the provided dictionaries, it is recommended to choose the smaller one that fits to your application.
+For instance, if you need 200 markers of 6x6 bits, it is better to use DICT_6X6_250 than DICT_6X6_1000.
+The smaller the dictionary, the higher the inter-marker distance.
+
+- Automatic dictionary generation:
+
+The dictionary can be generated automatically to adjust to the desired number of markers and bits, so that
+the inter-marker distance is optimized:
+
+@code{.cpp}
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::generateCustomDictionary(36, 5);
+@endcode
+
+This will generate a customized dictionary composed by 36 markers of 5x5 bits. The process can take several
+seconds, depending on the parameters (it is slower for larger dictionaries and higher number of bits).
+
+- Manually dictionary generation:
+
+Finally, the dictionary can be configured manually, so that any codification can be employed. To do that,
+the ```Dictionary``` object parameters need to be assigned manually. It must be noted that, unless you have
+ a special reason to do this manually, it is preferable to use one of the previous alternatives.
+
+The ```Dictionary``` parameters are:
+
+
+@code{.cpp}
+    class Dictionary {
+        public:
+
+        Mat bytesList;
+        int markerSize;
+        int maxCorrectionBits; // maximum number of bits that can be corrected
+
+        ...
+
+    }
+@endcode
+
+<code>bytesList</code> is the array that contains all the information about the marker codes. ```markerSize``` is the size
+ of each marker dimension (for instance, 5 for markers with 5x5 bits). Finally, ```maxCorrectionBits``` is
+the maximum number of erroneous bits that can be corrected during the marker detection. If this value is too
+high, it can lead to a high amount of false positives.
+
+Each row in ```bytesList``` represents one of the dictionary markers. However, the markers are not stored in its
+binary form, instead they are stored in a special format to simplificate their detection.
+
+Fortunately, a marker can be easily transformed to this form using the static method ```Dictionary::getByteListFromBits()```.
+
+For example:
+
+@code{.cpp}
+    cv::aruco::Dictionary dictionary;
+    // markers of 6x6 bits
+    dictionary.markerSize = 6;
+    // maximum number of bit corrections
+    dictionary.maxCorrectionBits = 3;
+
+    // lets create a dictionary of 100 markers
+    for(int i=0; i<100; i++)
+    {
+        // assume generateMarkerBits() generate a new marker in binary format, so that
+        // markerBits is a 6x6 matrix of CV_8UC1 type, only containing 0s and 1s
+        cv::Mat markerBits = generateMarkerBits();
+        cv::Mat markerCompressed = cv::aruco::Dictionary::getByteListFromBits(markerBits);
+        // add the marker as a new row
+        dictionary.bytesList.push_back(markerCompressed);
+    }
+@endcode
+
+
+
+
+Detector Parameters
+------
+
+One of the parameters of ```detectMarkers()``` function is a ```DetectorParameters``` object. This object
+includes all the options that can be customized during the marker detection process.
+
+In this section, all these parameters are commented. The parameters can be classified depending on
+the process they are involved:
+
+#### Thresholding
+
+One of the first steps of the marker detection process is an adaptive thresholding of the input image.
+
+For instance, the thresholded image for the sample image used above is:
+
+![Thresholded image](images/singlemarkersthresh.png)
+
+This thresholding can be customized in the following parameters:
+
+- ```int adaptiveThreshWinSizeMin```, ```int adaptiveThreshWinSizeMax```, ```int adaptiveThreshWinSizeStep```
+
+The ```adaptiveThreshWinSizeMin``` and ```adaptiveThreshWinSizeMax``` parameters represent the interval where the
+thresholding window sizes (in pixels) are selected for the adaptive thresholding (see OpenCV
+```threshold()``` function for more details).
+
+The parameter ```adaptiveThreshWinSizeStep``` indicates the increments on the window size from
+```adaptiveThreshWinSizeMin``` to adaptiveThreshWinSizeMax```.
+
+For instance, for the values ```adaptiveThreshWinSizeMin``` = 5 and adaptiveThreshWinSizeMax``` = 21 and
+```adaptiveThreshWinSizeStep``` = 4, there will be 5 thresholding steps with window sizes 5, 9, 13, 17 and 21.
+On each thresholding image, marker candidates will be extracted.
+
+Low values of window size can 'break' the marker border if the marker size is too large, and
+it would not be detected, like in the following image:
+
+![Broken marker image](images/singlemarkersbrokenthresh.png)
+
+On the other hand, too high values can produce the same effect if the markers are too small, and it can also
+reduce the performance. Moreover the process would tend to a global thresholding, losing the adaptive benefits.
+
+The simplest case is using the same value for ```adaptiveThreshWinSizeMin``` and
+ ```adaptiveThreshWinSizeMax```, which produces a single thresholding step. However, it is usually better using a
+ range of values for the window size, although many thresholding steps can also reduce the performance considerably.
+
+Default values:
+
+```adaptiveThreshWinSizeMin```: 3, ```adaptiveThreshWinSizeMax```: 23, ```adaptiveThreshWinSizeStep```: 10
+
+
+- ```double adaptiveThreshConstant```
+
+This parameter represents the constant value added in the thresholding condition (see OpenCV
+```threshold()``` function for more details). Its default value is a good option in most cases.
+
+Default value: 7
+
+
+#### Contour filtering
+
+After thresholding, contours are detected. However, not all contours
+are considered as marker candidates. They are filtered out in different steps so that contours that are
+very unlikely to be markers are discarded. The parameters in this section customize
+this filtering process.
+
+It must be noted that in most cases it is a question of balance between detection capacity
+and performance. All the considered contours will be processed in the following stages, which usually have
+a higher computational cost. So, it is preferred to discard wrong candidates in this stage than in the later stages.
+
+On the other hand, if the filtering conditions are too strict, the real marker contours could be discarded and,
+hence, not detected.
+
+- ```double minMarkerPerimeterRate```, ```double maxMarkerPerimeterRate```
+
+These parameters determine the minimum and maximum size of a marker, concretely the maximum and
+minimum marker perimeter. They are not specified in absolute pixels values, instead they are
+specified relative to the maximum dimension of the input image.
+
+For instance, a image with size 640x480 and a minimum relative marker perimeter of 0.05 will lead
+to a minimum marker perimeter of 640x0.05 = 32 pixels, since 640 is the maximum dimension of the
+image. The same applies for the ```maxMarkerPerimeterRate``` parameter.
+
+If the ```minMarkerPerimeterRate``` is too low, it can penalize considerably the detection performance since
+many more contours would be considered for future stages.
+This penalization is not so noticeable for the ```maxMarkerPerimeterRate``` parameter, since there are
+usually many more small contours than big contours.
+A ```minMarkerPerimeterRate``` value of 0 and a ```maxMarkerPerimeterRate``` value of 4 (or more) will be
+equivalent to consider all the contours in the image, however this is not recommended for
+the performance reasons.
+
+Default values:
+
+ ```minMarkerPerimeterRate``` : 0.03, ```maxMarkerPerimeterRate``` : 4.0
+
+
+- ```double polygonalApproxAccuracyRate```
+
+A polygonal approximation is applied to each candidate and only those that approximate to a square
+shape are accepted. This value determines the maximum error that the polygonal approximation can
+produce (see ```approxPolyDP()``` function for more information).
+
+This parameter is relative to the candidate length (in pixels). So if the candidate has
+a perimeter of 100 pixels and the value of ```polygonalApproxAccuracyRate``` is 0.04, the maximum error
+would be 100x0.04=5.4 pixels.
+
+In most cases, the default value works fine, but higher error values could be necessary for high
+distorted images.
+
+Default value: 0.05
+
+
+- ```double minCornerDistanceRate```
+
+Minimum distance between any pair of corners in the same marker. It is expressed relative to the marker
+perimeter. Minimum distance in pixels is Perimeter * minCornerDistanceRate.
+
+Default value: 0.05
+
+- ```double minMarkerDistanceRate```
+
+Minimum distance between any pair of corners from two different markers. It is expressed relative to
+the minimum marker perimeter of the two markers. If two candidates are too close, the smaller one is ignored.
+
+Default value: 0.05
+
+- ```int minDistanceToBorder```
+
+Minimum distance to any of the marker corners to the image border (in pixels). Markers partially occluded
+by the image border can be correctly detected if the occlusion is small. However, if one of the corner
+is occluded, the returned corner is usually placed in a wrong position near the image border.
+
+If the position of marker corners is important, for instance if you want to do pose estimation, it is
+better to discard markers with any of their corners are too close to the image border. Elsewhere, it is not necessary.
+
+Default value: 3
+
+
+#### Bits Extraction
+
+After candidate detection, the bits of each candidate are analyzed in order to determine if they
+are markers or not.
+
+Before analyzing the binary code itself, the bits need to be extracted. To do so, the perspective
+distortion is removed and the resulting image is thresholded using Otsu threshold to separate
+black and white pixels.
+
+This is an example of the image obtained after removing the perspective distortion of a marker:
+
+![Perspective removing](images/removeperspective.png)
+
+Then, the image is divided in a grid with the same cells than the number of bits in the marker.
+On each cell, the number of black and white pixels are counted to decide the bit assigned to the cell (from the majority value):
+
+![Marker cells](images/bitsextraction1.png)
+
+There are several parameters that can customize this process:
+
+- ```int markerBorderBits```
+
+This parameter indicates the width of the marker border. It is relative to the size of each bit. So, a
+value of 2 indicates the border has the width of two internal bits.
+
+This parameter needs to coincide with the border size of the markers you are using. The border size
+can be configured in the marker drawing functions such as ```drawMarker()```.
+
+Default value: 1
+
+- ```double minOtsuStdDev```
+
+This value determines the minimum standard deviation on the pixels values to perform Otsu
+thresholding. If the deviation is low, it probably means that all the square is black (or white)
+and applying Otsu does not make sense. If this is the case, all the bits are set to 0 (or 1)
+depending if the mean value is higher or lower than 128.
+
+Default value: 5.0
+
+ - ```int perspectiveRemovePixelPerCell```
+
+This parameter determines the number of pixels (per cell) in the obtained image after removing perspective
+distortion (including the border). This is the size of the red squares in the image above.
+
+For instance, lets assume we are dealing with markers of 5x5 bits and border size of 1 bit
+(see ```markerBorderBits```). Then, the total number of cells/bits per dimension is 5 + 2*1 = 7 (the border
+has to be counted twice). The total number of cells is 7x7.
+
+If the value of ```perspectiveRemovePixelPerCell``` is 10, then the size of the obtained image will be
+10*7 = 70 -> 70x70 pixels.
+
+A higher value of this parameter can improve the bits extraction process (up to some degree), however it can penalize
+the performance.
+
+Default value: 4
+
+- ```double perspectiveRemoveIgnoredMarginPerCell```
+
+When extracting the bits of each cell, the numbers of black and white pixels are counted. In general, it is
+not recommended to consider all the cell pixels. Instead it is better to ignore some pixels in the
+margins of the cells.
+
+The reason of this is that, after removing the perspective distortion, the cells' colors are, in general, not
+perfectly separated and white cells can invade some pixels of black cells (and vice-versa). Thus, it is
+better to ignore some pixels just to avoid counting erroneous pixels.
+
+For instance, in the following image:
+
+![Marker cell margins](images/bitsextraction2.png)
+
+only the pixels inside the green squares are considered. It can be seen in the right image that
+the resulting pixels contain a lower amount of noise from neighbor cells.
+The ```perspectiveRemoveIgnoredMarginPerCell``` parameter indicates the difference between the red and
+the green squares.
+
+This parameter is relative to the total size of the cell. For instance if the cell size is 40 pixels and the
+value of this parameter is 0.1, a margin of 40*0.1=4 pixels is ignored in the cells. This means that the total
+amount of pixels that would be analyzed on each cell would actually be 32x32, instead of 40x40.
+
+Default value: 0.13
+
+
+#### Marker identification
+
+After the bits have been extracted, the next step is checking if the extracted code belongs to the marker
+dictionary and, if necessary, error correction can be performed.
+
+- ```double maxErroneousBitsInBorderRate```
+
+The bits of the marker border should be black. This parameter specifies the allowed number of erroneous
+bits in the border, i.e. the maximum number of white bits in the border. It is represented
+relative to the total number of bits in the marker.
+
+Default value: 0.35
+
+
+- ```double errorCorrectionRate```
+
+Each marker dictionary has a theoretical maximum number of bits that can be corrected (```Dictionary.maxCorrectionBits```).
+However, this value can be modified by the ```errorCorrectionRate``` parameter.
+
+For instance, if the allowed number of bits that can be corrected (for the used dictionary) is 6 and the value of ```errorCorrectionRate``` is
+0.5, the real maximum number of bits that can be corrected is 6*0.5=3 bits.
+
+This value is useful to reduce the error correction capabilities in order to avoid false positives.
+
+Default value: 0.6
+
+
+#### Corner Refinement
+
+After markers have been detected and identified, the last step is performing subpixel refinement
+in the corner positions (see OpenCV ```cornerSubPix()``` and ```cv::aruco::CornerRefineMethod```)
+
+Note that this step is optional and it only makes sense if the position of the marker corners have to
+be accurate, for instance for pose estimation. It is usually a time consuming step and it is disabled by default.
+
+- ```int cornerRefinementMethod```
+
+This parameter determines if the corner subpixel process is performed or not. It can be disabled
+if accurate corners are not necessary.
+
+Default value: ```CORNER_REFINE_NONE```.
+
+ - ```int cornerRefinementWinSize```
+
+This parameter determines the window size of the subpixel refinement process.
+
+High values can produce the effect that close image corners are included in the window region, so that the
+marker corner moves to a different and wrong location during the process. Furthermore
+it can affect to performance.
+
+Default value: 5
+
+
+- ```int cornerRefinementMaxIterations```, ```double cornerRefinementMinAccuracy```
+
+These two parameters determine the stop criterion of the subpixel refinement process. The
+```cornerRefinementMaxIterations``` indicates the maximum number of iterations and
+```cornerRefinementMinAccuracy``` the minimum error value before stopping the process.
+
+If the number of iterations is too high, it can affect the performance. On the other hand, if it is
+too low, it can produce a poor subpixel refinement.
+
+Default values:
+
+```cornerRefinementMaxIterations```: 30, ```cornerRefinementMinAccuracy```: 0.1

aruco_pose/vendor/aruco/tutorials/aruco_faq/aruco_faq.markdown

@@ -0,0 +1,149 @@
+Aruco module FAQ {#tutorial_aruco_faq}
+==============================
+
+This is a compilation of questions that can be useful for those that want to use the aruco module.
+
+- I only want to label some objects, what should I use?
+
+In this case, you only need single ArUco markers. You can place one or several markers with different ids in each of the object you want to identify.
+
+
+- Which algorithm is used for marker detection?
+
+The aruco module is based on the original ArUco library. A full description of the detection process can be found in:
+
+> S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+> "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+> Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+
+
+- My markers are not being detected correctly, what can I do?
+
+There can be many factors that avoid the correct detection of markers. You probably need to adjust some of the parameters
+in the ```DetectorParameters``` object. The first thing you can do is checking if your markers are returned
+as rejected candidates by the ```detectMarkers()``` function. Depending on this, you should try to modify different parameters.
+
+If you are using a ArUco board, you can also try the ```refineDetectedMarkers()``` function.
+
+
+- What are the benefits of ArUco boards? What are the drawbacks?
+
+Using a board of markers you can obtain the camera pose from a set of markers, instead of a single one. This way,
+the detection is able to handle occlusion of partial views of the Board, since only one marker is necessary to obtain the pose.
+
+Furthermore, as in most cases you are using more corners for pose estimation, it will be more accurate than using a single marker.
+
+The main drawback is that a Board is not as versatile as a single marker.
+
+
+
+- What are the benefits of ChArUco boards over ArUco boards? And the drawbacks?
+
+ChArUco boards combines chessboards with ArUco boards. Thanks to this, the corners provided by ChArUco boards are more accurate than those provided by ArUco Boards (or single markers).
+
+The main drawback is that ChArUco boards are not as versatile as ArUco board. For instance, a ChArUco board is a planar board with a specific marker layout while the ArUco boards
+can have any layout, even in 3d. Furthermore, the markers in the ChArUco board are usually smaller and more difficult to detect.
+
+
+- I do not need pose estimation, should I use ChArUco boards?
+
+No. The main goal of ChArUco boards is provide high accurate corners for pose estimation or camera calibration.
+
+
+- Should all the markers in an ArUco board be placed in the same plane?
+
+No, the marker corners in a ArUco board can be placed anywhere in its 3d coordinate system.
+
+
+- Should all the markers in an ChArUco board be placed in the same plane?
+
+Yes, all the markers in a ChArUco board need to be in the same plane and their layout is fixed by the chessboard shape.
+
+
+- What is the difference between a ```Board``` object and a ```GridBoard``` object?
+
+The ```GridBoard``` class is a specific type of board that inherits from ```Board``` class. A ```GridBoard``` object is a board whose markers are placed in the same
+plane and in a grid layout.
+
+
+- What are Diamond markers?
+
+Diamond markers are very similar to a ChArUco board of 3x3 squares. However, contrary to ChArUco boards, the detection of diamonds is based on the relative position of the markers.
+They are useful when you want to provide a conceptual meaning to any (or all) of the markers in the diamond. An example is using one of the marker to provide the diamond scale.
+
+
+- Do I need to detect marker before board detection, ChArUco board detection or Diamond detection?
+
+Yes, the detection of single markers is a basic tool in the aruco module. It is done using the ```detectMarkers()``` function. The rest of functionalities receives
+a list of detected markers from this function.
+
+
+- I want to calibrate my camera, can I use this module?
+
+Yes, the aruco module provides functionalities to calibrate the camera using both, ArUco boards and ChArUco boards.
+
+
+- Should I calibrate using a ChArUco board or an ArUco board?
+
+It is highly recommended the calibration using ChArUco board due to the high accuracy.
+
+
+- Should I use a predefined dictionary or generate my own dictionary?
+
+In general, it is easier to use one of the predefined dictionaries. However, if you need a bigger dictionary (in terms of number of markers or number of bits)
+you should generate your own dictionary. Dictionary generation is also useful if you want to maximize the inter-marker distance to achieve a better error
+correction during the identification step.
+
+- I am generating my own dictionary but it takes too long
+
+Dictionary generation should only be done once at the beginning of your application and it should take some seconds. If you are
+generating the dictionary on each iteration of your detection loop, you are doing it wrong.
+
+Furthermore, it is recommendable to save the dictionary to a file and read it on every execution so you dont need to generate it.
+
+
+- I would like to use some markers of the original ArUco library that I have already printed, can I use them?
+
+Yes, one of the predefined dictionary is ```DICT_ARUCO_ORIGINAL```, which detects the marker of the original ArUco library with the same identifiers.
+
+
+- Can I use the Board configuration file of the original ArUco library in this module?
+
+Not directly, you will need to adapt the information of the ArUco file to the aruco module Board format.
+
+
+- Can I use this module to detect the markers of other libraries based on binary fiducial markers?
+
+Probably yes, however you will need to port the dictionary of the original library to the aruco module format.
+
+
+- Do I need to store the Dictionary information in a file so I can use it in different executions?
+
+If you are using one of the predefined dictionaries, it is not necessary. Otherwise, it is recommendable that you save it to file.
+
+
+- Do I need to store the Board information in a file so I can use it in different executions?
+
+If you are using a ```GridBoard``` or a ```ChArUco``` board you only need to store the board measurements that are provided to the ```GridBoard::create()``` or ```ChArUco::create()``` functions.
+If you manually modify the marker ids of the boards, or if you use a different type of board, you should save your board object to file.
+
+- Does the aruco module provide functions to save the Dictionary or Board to file?
+
+Not right now. However the data member of both the dictionary and board classes are public and can be easily stored.
+
+
+- Alright, but how can I render a 3d model to create an augmented reality application?
+
+To do so, you will need to use an external rendering engine library, such as OpenGL. The aruco module only provides the functionality to
+obtain the camera pose, i.e. the rotation and traslation vectors, which is necessary to create the augmented reality effect.
+However, you will need to adapt the rotation and traslation vectors from the OpenCV format to the format accepted by your 3d rendering library.
+The original ArUco library contains examples of how to do it for OpenGL and Ogre3D.
+
+
+- I have use this module in my research work, how can I cite it?
+
+You can cite the original ArUco library:
+
+> S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+> "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+> Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005

aruco_pose/vendor/aruco/tutorials/charuco_detection/charuco_detection.markdown

@@ -0,0 +1,329 @@
+Detection of ChArUco Corners {#tutorial_charuco_detection}
+==============================
+
+ArUco markers and boards are very useful due to their fast detection and their versatility.
+However, one of the problems of ArUco markers is that the accuracy of their corner positions is not too high,
+even after applying subpixel refinement.
+
+On the contrary, the corners of chessboard patterns can be refined more accurately since each corner is
+surrounded by two black squares. However, finding a chessboard pattern is not as versatile as finding an ArUco board:
+it has to be completely visible and occlusions are not permitted.
+
+A ChArUco board tries to combine the benefits of these two approaches:
+
+![Charuco definition](images/charucodefinition.png)
+
+The ArUco part is used to interpolate the position of the chessboard corners, so that it has the versatility of marker
+boards, since it allows occlusions or partial views. Moreover, since the interpolated corners belong to a chessboard,
+they are very accurate in terms of subpixel accuracy.
+
+When high precision is necessary, such as in camera calibration, Charuco boards are a better option than standard
+Aruco boards.
+
+
+ChArUco Board Creation
+------
+
+The aruco module provides the ```cv::aruco::CharucoBoard``` class that represents a Charuco Board and which inherits from the ```Board``` class.
+
+This class, as the rest of ChArUco functionalities, are defined in:
+
+@code{.cpp}
+    #include <opencv2/aruco/charuco.hpp>
+@endcode
+
+To define a ```CharucoBoard```, it is necesary:
+
+- Number of chessboard squares in X direction.
+- Number of chessboard squares in Y direction.
+- Length of square side.
+- Length of marker side.
+- The dictionary of the markers.
+- Ids of all the markers.
+
+As for the ```GridBoard``` objects, the aruco module provides a function to create ```CharucoBoard```s easily. This function
+is the static function ```cv::aruco::CharucoBoard::create()``` :
+
+@code{.cpp}
+    cv::aruco::CharucoBoard board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+@endcode
+
+- The first and second parameters are the number of squares in X and Y direction respectively.
+- The third and fourth parameters are the length of the squares and the markers respectively. They can be provided
+in any unit, having in mind that the estimated pose for this board would be measured in the same units (usually meters are used).
+- Finally, the dictionary of the markers is provided.
+
+The ids of each of the markers are assigned by default in ascending order and starting on 0, like in ```GridBoard::create()```.
+This can be easily customized by accessing to the ids vector through ```board.ids```, like in the ```Board``` parent class.
+
+Once we have our ```CharucoBoard``` object, we can create an image to print it. This can be done with the
+<code>CharucoBoard::draw()</code> method:
+
+@code{.cpp}
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+    cv::Mat boardImage;
+    board->draw( cv::Size(600, 500), boardImage, 10, 1 );
+@endcode
+
+- The first parameter is the size of the output image in pixels. In this case 600x500 pixels. If this is not proportional
+to the board dimensions, it will be centered on the image.
+- ```boardImage```: the output image with the board.
+- The third parameter is the (optional) margin in pixels, so none of the markers are touching the image border.
+In this case the margin is 10.
+- Finally, the size of the marker border, similarly to ```drawMarker()``` function. The default value is 1.
+
+The output image will be something like this:
+
+![](images/charucoboard.jpg)
+
+A full working example is included in the ```create_board_charuco.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "_ output path_/chboard.png" -w=5 -h=7 -sl=200 -ml=120 -d=10
+@endcode
+
+
+ChArUco Board Detection
+------
+
+When you detect a ChArUco board, what you are actually detecting is each of the chessboard corners of the board.
+
+Each corner on a ChArUco board has a unique identifier (id) assigned. These ids go from 0 to the total number of corners
+in the board.
+
+So, a detected ChArUco board consists in:
+
+- ```std::vector<cv::Point2f> charucoCorners``` : list of image positions of the detected corners.
+- ```std::vector<int> charucoIds``` : ids for each of the detected corners in ```charucoCorners```.
+
+The detection of the ChArUco corners is based on the previous detected markers. So that, first markers are detected, and then
+ChArUco corners are interpolated from markers.
+
+The function that detect the ChArUco corners is ```cv::aruco::interpolateCornersCharuco()``` . This example shows the whole process. First, markers are detected, and then the ChArUco corners are interpolated from these markers.
+
+@code{.cpp}
+    cv::Mat inputImage;
+    cv::Mat cameraMatrix, distCoeffs;
+    // camera parameters are read from somewhere
+    readCameraParameters(cameraMatrix, distCoeffs);
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+    ...
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> markerCorners;
+    cv::aruco::detectMarkers(inputImage, board.dictionary, markerCorners, markerIds);
+
+    // if at least one marker detected
+    if(markerIds.size() > 0) {
+        std::vector<cv::Point2f> charucoCorners;
+        std::vector<int> charucoIds;
+        cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, inputImage, board, charucoCorners, charucoIds, cameraMatrix, distCoeffs);
+    }
+@endcode
+
+The parameters of the ```interpolateCornersCharuco()``` function are:
+- ```markerCorners``` and ```markerIds```: the detected markers from ```detectMarkers()``` function.
+- ```inputImage```: the original image where the markers were detected. The image is necessary to perform subpixel refinement
+in the ChArUco corners.
+- ```board```: the ```CharucoBoard``` object
+- ```charucoCorners``` and ```charucoIds```: the output interpolated Charuco corners
+- ```cameraMatrix``` and ```distCoeffs```: the optional camera calibration parameters
+- The function returns the number of Charuco corners interpolated.
+
+In this case, we have call ```interpolateCornersCharuco()``` providing the camera calibration parameters. However these parameters
+are optional. A similar example without these parameters would be:
+
+@code{.cpp}
+    cv::Mat inputImage;
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+    ...
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> markerCorners;
+    cv::Ptr<cv::aruco::DetectorParameters> params;
+    params->cornerRefinementMethod = cv::aruco::CORNER_REFINE_NONE;
+    cv::aruco::detectMarkers(inputImage, board.dictionary, markerCorners, markerIds, params);
+
+    // if at least one marker detected
+    if(markerIds.size() > 0) {
+        std::vector<cv::Point2f> charucoCorners;
+        std::vector<int> charucoIds;
+        cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, inputImage, board, charucoCorners, charucoIds);
+    }
+@endcode
+
+If calibration parameters are provided, the ChArUco corners are interpolated by, first, estimating a rough pose from the ArUco markers
+and, then, reprojecting the ChArUco corners back to the image.
+
+On the other hand, if calibration parameters are not provided, the ChArUco corners are interpolated by calculating the
+corresponding homography between the ChArUco plane and the ChArUco image projection.
+
+The main problem of using homography is that the interpolation is more sensible to image distortion. Actually, the homography is only performed
+using the closest markers of each ChArUco corner to reduce the effect of distortion.
+
+When detecting markers for ChArUco boards, and specially when using homography, it is recommended to disable the corner refinement of markers. The reason of this
+is that, due to the proximity of the chessboard squares, the subpixel process can produce important
+deviations in the corner positions and these deviations are propagated to the ChArUco corner interpolation,
+producing poor results.
+
+Furthermore, only those corners whose two surrounding markers have be found are returned. If any of the two surrounding markers has
+not been detected, this usually means that there is some occlusion or the image quality is not good in that zone. In any case, it is
+preferable not to consider that corner, since what we want is to be sure that the interpolated ChArUco corners are very accurate.
+
+After the ChArUco corners have been interpolated, a subpixel refinement is performed.
+
+Once we have interpolated the ChArUco corners, we would probably want to draw them to see if their detections are correct.
+This can be easily done using the ```drawDetectedCornersCharuco()``` function:
+
+@code{.cpp}
+    cv::aruco::drawDetectedCornersCharuco(image, charucoCorners, charucoIds, color);
+@endcode
+
+- ```image``` is the image where the corners will be drawn (it will normally be the same image where the corners were detected).
+- The ```outputImage``` will be a clone of ```inputImage``` with the corners drawn.
+- ```charucoCorners``` and ```charucoIds``` are the detected Charuco corners from the ```interpolateCornersCharuco()``` function.
+- Finally, the last parameter is the (optional) color we want to draw the corners with, of type ```cv::Scalar```.
+
+For this image:
+
+![Image with Charuco board](images/choriginal.png)
+
+The result will be:
+
+![Charuco board detected](images/chcorners.png)
+
+In the presence of occlusion. like in the following image, although some corners are clearly visible, not all their surrounding markers have been detected due occlusion and, thus, they are not interpolated:
+
+![Charuco detection with occlusion](images/chocclusion.png)
+
+Finally, this is a full example of ChArUco detection (without using calibration parameters):
+
+@code{.cpp}
+    cv::VideoCapture inputVideo;
+    inputVideo.open(0);
+
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+
+    cv::Ptr<cv::aruco::DetectorParameters> params;
+    params->cornerRefinementMethod = cv::aruco::CORNER_REFINE_NONE;
+
+    while (inputVideo.grab()) {
+        cv::Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        image.copyTo(imageCopy);
+
+        std::vector<int> ids;
+        std::vector<std::vector<cv::Point2f>> corners;
+        cv::aruco::detectMarkers(image, dictionary, corners, ids, params);
+
+        // if at least one marker detected
+        if (ids.size() > 0) {
+            cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
+
+            std::vector<cv::Point2f> charucoCorners;
+            std::vector<int> charucoIds;
+            cv::aruco::interpolateCornersCharuco(corners, ids, image, board, charucoCorners, charucoIds);
+            // if at least one charuco corner detected
+            if(charucoIds.size() > 0)
+                cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
+        }
+
+        cv::imshow("out", imageCopy);
+        char key = (char) cv::waitKey(waitTime);
+        if (key == 27)
+            break;
+    }
+@endcode
+
+Sample video:
+
+@htmlonly
+<iframe width="420" height="315" src="https://www.youtube.com/embed/Nj44m_N_9FY" frameborder="0" allowfullscreen></iframe>
+@endhtmlonly
+
+A full working example is included in the ```detect_board_charuco.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_path_/calib.txt" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
+@endcode
+
+ChArUco Pose Estimation
+------
+
+The final goal of the ChArUco boards is finding corners very accurately for a high precision calibration or pose estimation.
+
+The aruco module provides a function to perform ChArUco pose estimation easily. As in the ```GridBoard```, the coordinate system
+of the ```CharucoBoard``` is placed in the board plane with the Z axis pointing out, and centered in the bottom left corner of the board.
+
+The function for pose estimation is ```estimatePoseCharucoBoard()```:
+
+@code{.cpp}
+    cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
+@endcode
+
+- The ```charucoCorners``` and ```charucoIds``` parameters are the detected charuco corners from the ```interpolateCornersCharuco()```
+function.
+- The third parameter is the ```CharucoBoard``` object.
+- The ```cameraMatrix``` and ```distCoeffs``` are the camera calibration parameters which are necessary for pose estimation.
+- Finally, the ```rvec``` and ```tvec``` parameters are the output pose of the Charuco Board.
+- The function returns true if the pose was correctly estimated and false otherwise. The main reason of failing is that there are
+not enough corners for pose estimation or they are in the same line.
+
+The axis can be drawn using ```drawAxis()``` to check the pose is correctly estimated. The result would be: (X:red, Y:green, Z:blue)
+
+![Charuco Board Axis](images/chaxis.png)
+
+A full example of ChArUco detection with pose estimation:
+
+@code{.cpp}
+    cv::VideoCapture inputVideo;
+    inputVideo.open(0);
+
+    cv::Mat cameraMatrix, distCoeffs;
+    // camera parameters are read from somewhere
+    readCameraParameters(cameraMatrix, distCoeffs);
+
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary);
+
+    while (inputVideo.grab()) {
+        cv::Mat image, imageCopy;
+        inputVideo.retrieve(image);
+        image.copyTo(imageCopy);
+
+        std::vector<int> ids;
+        std::vector<std::vector<cv::Point2f>> corners;
+        cv::aruco::detectMarkers(image, dictionary, corners, ids);
+
+        // if at least one marker detected
+        if (ids.size() > 0) {
+            std::vector<cv::Point2f> charucoCorners;
+            std::vector<int> charucoIds;
+            cv::aruco::interpolateCornersCharuco(corners, ids, image, board, charucoCorners, charucoIds, cameraMatrix, distCoeffs);
+            // if at least one charuco corner detected
+            if(charucoIds.size() > 0) {
+                cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
+                cv::Vec3d rvec, tvec;
+                bool valid = cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
+                // if charuco pose is valid
+                if(valid)
+                    cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvec, tvec, 0.1);
+            }
+        }
+
+        cv::imshow("out", imageCopy);
+        char key = (char) cv::waitKey(waitTime);
+        if (key == 27)
+            break;
+    }
+@endcode
+
+A full working example is included in the ```detect_board_charuco.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "_path_/calib.txt" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
+@endcode

aruco_pose/vendor/aruco/tutorials/charuco_diamond_detection/charuco_diamond_detection.markdown

@@ -0,0 +1,174 @@
+Detection of Diamond Markers {#tutorial_charuco_diamond_detection}
+==============================
+
+A ChArUco diamond marker (or simply diamond marker) is a chessboard composed by 3x3 squares and 4 ArUco markers inside the white squares.
+It is similar to a ChArUco board in appearance, however they are conceptually different.
+
+![Diamond marker examples](images/diamondmarkers.png)
+
+In both, ChArUco board and Diamond markers, their detection is based on the previous detected ArUco
+markers. In the ChArUco case, the used markers are selected by directly looking their identifiers. This means
+that if a marker (included in the board) is found on a image, it will be automatically assumed to belong to the board. Furthermore,
+if a marker board is found more than once in the image, it will produce an ambiguity since the system wont
+be able to know which one should be used for the Board.
+
+On the other hand, the detection of Diamond marker is not based on the identifiers. Instead, their detection
+is based on the relative position of the markers. As a consequence, marker identifiers can be repeated in the
+same diamond or among different diamonds, and they can be detected simultaneously without ambiguity. However,
+due to the complexity of finding marker based on their relative position, the diamond markers are limited to
+a size of 3x3 squares and 4 markers.
+
+As in a single ArUco marker, each Diamond marker is composed by 4 corners and a identifier. The four corners
+correspond to the 4 chessboard corners in the marker and the identifier is actually an array of 4 numbers, which are
+the identifiers of the four ArUco markers inside the diamond.
+
+Diamond markers are useful in those scenarios where repeated markers should be allowed. For instance:
+
+- To increase the number of identifiers of single markers by using diamond marker for labeling. They would allow
+up to N^4 different ids, being N the number of markers in the used dictionary.
+
+- Give to each of the four markers a conceptual meaning. For instance, one of the four marker ids could be
+used to indicate the scale of the marker (i.e. the size of the square), so that the same diamond can be found
+in the environment with different sizes just by changing one of the four markers and the user does not need
+to manually indicate the scale of each of them. This case is included in the ```diamond_detector.cpp``` file inside
+the samples folder of the module.
+
+Furthermore, as its corners are chessboard corners, they can be used for accurate pose estimation.
+
+The diamond functionalities are included in ```<opencv2/aruco/charuco.hpp>```
+
+
+ChArUco Diamond Creation
+------
+
+The image of a diamond marker can be easily created using the ```drawCharucoDiamond()``` function.
+For instance:
+
+@code{.cpp}
+    cv::Mat diamondImage;
+    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
+    cv::aruco::drawCharucoDiamond(dictionary, cv::Vec4i(45,68,28,74), 200, 120, markerImage);
+@endcode
+
+This will create a diamond marker image with a square size of 200 pixels and a marker size of 120 pixels.
+The marker ids are given in the second parameter as a ```Vec4i``` object. The order of the marker ids
+in the diamond layout are the same as in a standard ChArUco board, i.e. top, left, right and bottom.
+
+The image produced will be:
+
+![Diamond marker](images/diamondmarker.png)
+
+A full working example is included in the ```create_diamond.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    "_path_/mydiamond.png" -sl=200 -ml=120 -d=10 -ids=45,68,28,74
+@endcode
+
+ChArUco Diamond Detection
+------
+
+As in most cases, the detection of diamond markers requires a previous detection of ArUco markers.
+After detecting markers, diamond are detected using the ```detectCharucoDiamond()``` function:
+
+@code{.cpp}
+    cv::Mat inputImage;
+    float squareLength = 0.40;
+    float markerLength = 0.25;
+    ...
+
+
+    std::vector<int> markerIds;
+    std::vector<std::vector< cv::Point2f>> markerCorners;
+
+    // detect ArUco markers
+    cv::aruco::detectMarkers(inputImage, dictionary, markerCorners, markerIds);
+
+    std::vector<cv::Vec4i> diamondIds;
+    std::vector<std::vector<cv::Point2f>> diamondCorners;
+
+    // detect diamon diamonds
+    cv::aruco::detectCharucoDiamond(inputImage, markerCorners, markerIds, squareLength / markerLength, diamondCorners, diamondIds);
+@endcode
+
+The ```detectCharucoDiamond()``` function receives the original image and the previous detected marker corners and ids.
+The input image is necessary to perform subpixel refinement in the ChArUco corners.
+It also receives the rate between the square size and the marker sizes which is required for both, detecting the diamond
+from the relative positions of the markers and interpolating the ChArUco corners.
+
+The function returns the detected diamonds in two parameters. The first parameter, ```diamondCorners```, is an array containing
+all the four corners of each detected diamond. Its format is similar to the detected corners by the ```detectMarkers()```
+function and, for each diamond, the corners are represented in the same order than in the ArUco markers, i.e. clockwise order
+starting with the top-left corner. The second returned parameter, ```diamondIds```, contains all the ids of the returned
+diamond corners in ```diamondCorners```. Each id is actually an array of 4 integers that can be represented with ```Vec4i```.
+
+The detected diamond can be visualized using the function ```drawDetectedDiamonds()``` which simply recieves the image and the diamond
+corners and ids:
+
+@code{.cpp}
+    ...
+    std::vector<cv::Vec4i> diamondIds;
+    std::vector<std::vector<cv::Point2f>> diamondCorners;
+    cv::aruco::detectCharucoDiamond(inputImage, markerCorners, markerIds, squareLength / markerLength, diamondCorners, diamondIds);
+
+    cv::aruco::drawDetectedDiamonds(inputImage, diamondCorners, diamondIds);
+@endcode
+
+The result is the same that the one produced by ```drawDetectedMarkers()```, but printing the four ids of the diamond:
+
+![Detected diamond markers](images/detecteddiamonds.png)
+
+A full working example is included in the ```detect_diamonds.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_path_/calib.txt" -dp="_path_/detector_params.yml" -sl=0.04 -ml=0.02 -d=10
+@endcode
+
+ChArUco Diamond Pose Estimation
+------
+
+Since a ChArUco diamond is represented by its four corners, its pose can be estimated in the same way than in a single ArUco marker,
+i.e. using the ```estimatePoseSingleMarkers()``` function. For instance:
+
+@code{.cpp}
+    ...
+
+    std::vector<cv::Vec4i> diamondIds;
+    std::vector<std::vector<cv::Point2f>> diamondCorners;
+
+    // detect diamon diamonds
+    cv::aruco::detectCharucoDiamond(inputImage, markerCorners, markerIds, squareLength / markerLength, diamondCorners, diamondIds);
+
+    // estimate poses
+    std::vector<cv::Vec3d> rvecs, tvecs;
+    cv::aruco::estimatePoseSingleMarkers(diamondCorners, squareLength, camMatrix, distCoeffs, rvecs, tvecs);
+
+    // draw axis
+    for(unsigned int i=0; i<rvecs.size(); i++)
+        cv::aruco::drawAxis(inputImage, camMatrix, distCoeffs, rvecs[i], tvecs[i], axisLength);
+@endcode
+
+The function will obtain the rotation and translation vector for each of the diamond marker and store them
+in ```rvecs``` and ```tvecs```. Note that the diamond corners are a chessboard square corners and thus, the square length
+has to be provided for pose estimation, and not the marker length. Camera calibration parameters are also required.
+
+Finally, an axis can be drawn to check the estimated pose is correct using ```drawAxis()```:
+
+![Detected diamond axis](images/diamondsaxis.png)
+
+The coordinate system of the diamond pose will be in the center of the marker with the Z axis pointing out,
+as in a simple ArUco marker pose estimation.
+
+Sample video:
+
+@htmlonly
+<iframe width="420" height="315" src="https://www.youtube.com/embed/OqKpBnglH7k" frameborder="0" allowfullscreen></iframe>
+@endhtmlonly
+
+A full working example is included in the ```detect_diamonds.cpp``` inside the module samples folder.
+
+Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
+@code{.cpp}
+    -c="_output path_/calib.txt" -dp="_path_/detector_params.yml" -sl=0.04 -ml=0.02 -d=10
+@endcode

aruco_pose/vendor/aruco/tutorials/table_of_content_aruco.markdown

@@ -0,0 +1,60 @@
+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