(5.x) Merge 4.x

modules/aruco/CMakeLists.txt

@@ -1,5 +1,5 @@
 set(the_description "ArUco Marker Detection")
-ocv_define_module(aruco opencv_core opencv_imgproc opencv_3d opencv_calib WRAP python java objc js)
+ocv_define_module(aruco opencv_core opencv_imgproc opencv_3d opencv_calib opencv_objdetect WRAP python java objc js)
 ocv_include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 ocv_add_testdata(samples/ contrib/aruco

modules/aruco/include/opencv2/aruco.hpp

@@ -1,33 +1,100 @@
 // 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_ARUCO_HPP__
-#define __OPENCV_ARUCO_HPP__
+#ifndef OPENCV_ARUCO_HPP
+#define OPENCV_ARUCO_HPP
 
-#include "opencv2/aruco_detector.hpp"
-#include "opencv2/aruco/aruco_calib_pose.hpp"
+#include "opencv2/objdetect/aruco_detector.hpp"
+#include "opencv2/aruco/aruco_calib.hpp"
 
 namespace cv {
 namespace aruco {
 
-
 /**
-@deprecated Use class ArucoDetector
+ * @defgroup aruco Aruco markers, module functionality was moved to objdetect module
+ * @{
+ * ArUco Marker Detection, module functionality was moved to objdetect module
+ * @sa ArucoDetector, CharucoDetector, Board, GridBoard, CharucoBoard
+ * @}
+ */
+
+//! @addtogroup aruco
+//! @{
+
+/** @brief detect markers
+@deprecated Use class ArucoDetector::detectMarkers
 */
 CV_EXPORTS_W void detectMarkers(InputArray image, const Ptr<Dictionary> &dictionary, OutputArrayOfArrays corners,
-                                OutputArray ids, const Ptr<DetectorParameters> &parameters = DetectorParameters::create(),
+                                OutputArray ids, const Ptr<DetectorParameters> &parameters = makePtr<DetectorParameters>(),
                                 OutputArrayOfArrays rejectedImgPoints = noArray());
 
-/**
-@deprecated Use class ArucoDetector
+/** @brief refine detected markers
+@deprecated Use class ArucoDetector::refineDetectedMarkers
 */
 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());
+                                        const Ptr<DetectorParameters> &parameters = makePtr<DetectorParameters>());
+
+/** @brief draw planar board
+@deprecated Use Board::generateImage
+*/
+CV_EXPORTS_W void drawPlanarBoard(const Ptr<Board> &board, Size outSize, OutputArray img, int marginSize,
+                                  int borderBits);
+
+/** @brief get board object and image points
+@deprecated Use Board::matchImagePoints
+*/
+CV_EXPORTS_W void getBoardObjectAndImagePoints(const Ptr<Board> &board, InputArrayOfArrays detectedCorners,
+                                               InputArray detectedIds, OutputArray objPoints, OutputArray imgPoints);
+
+
+/** @deprecated Use cv::solvePnP
+ */
+CV_EXPORTS_W int estimatePoseBoard(InputArrayOfArrays corners, InputArray ids, const Ptr<Board> &board,
+                                   InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec,
+                                   InputOutputArray tvec, bool useExtrinsicGuess = false);
+
+/**
+ * @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.
+ * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
+ */
+CV_EXPORTS_W bool estimatePoseCharucoBoard(InputArray charucoCorners, InputArray charucoIds,
+                                           const Ptr<CharucoBoard> &board, InputArray cameraMatrix,
+                                           InputArray distCoeffs, InputOutputArray rvec,
+                                           InputOutputArray tvec, bool useExtrinsicGuess = false);
+
+/** @deprecated Use cv::solvePnP
+ */
+CV_EXPORTS_W void estimatePoseSingleMarkers(InputArrayOfArrays corners, float markerLength,
+                                            InputArray cameraMatrix, InputArray distCoeffs,
+                                            OutputArray rvecs, OutputArray tvecs, OutputArray objPoints = noArray(),
+                                            const Ptr<EstimateParameters>& estimateParameters = makePtr<EstimateParameters>());
+
+
+/** @deprecated Use CharucoBoard::checkCharucoCornersCollinear
+ */
+CV_EXPORTS_W bool testCharucoCornersCollinear(const Ptr<CharucoBoard> &board, InputArray charucoIds);
+
+//! @}
 
 }
 }

modules/aruco/include/opencv2/aruco/aruco_calib_pose.hpp → modules/aruco/include/opencv2/aruco/aruco_calib.hpp

@@ -1,10 +1,9 @@
 // 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_ARUCO_CALIB_POSE_HPP__
-#define __OPENCV_ARUCO_CALIB_POSE_HPP__
-#include <opencv2/aruco/board.hpp>
-#include <opencv2/calib3d.hpp>
+#ifndef OPENCV_ARUCO_CALIB_POSE_HPP
+#define OPENCV_ARUCO_CALIB_POSE_HPP
+#include <opencv2/objdetect/aruco_board.hpp>
 
 namespace cv {
 namespace aruco {
@@ -13,143 +12,54 @@ namespace aruco {
 //! @{
 
 /** @brief rvec/tvec define the right handed coordinate system of the marker.
- * PatternPos defines center this system and axes direction.
+ *
+ * PatternPositionType defines center this system and axes direction.
  * Axis X (red color) - first coordinate, axis Y (green color) - second coordinate,
  * axis Z (blue color) - third coordinate.
- * @sa estimatePoseSingleMarkers(), @ref tutorial_aruco_detection
+ * @sa estimatePoseSingleMarkers(), check tutorial_aruco_detection in aruco contrib
  */
-enum PatternPos {
+enum PatternPositionType {
     /** @brief The marker coordinate system is centered on the middle of the marker.
+     *
      * The coordinates of the four corners (CCW order) 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).
      *
      * These pattern points define this coordinate system:
-     * ![Image with axes drawn](images/singlemarkersaxes.jpg)
+     * ![Image with axes drawn](tutorials/images/singlemarkersaxes.jpg)
      */
     ARUCO_CCW_CENTER,
     /** @brief The marker coordinate system is centered on the top-left corner of the marker.
+     *
      * The coordinates of the four corners (CW order) of the marker in its own coordinate system are:
      * (0, 0, 0), (markerLength, 0, 0),
      * (markerLength, markerLength, 0), (0, markerLength, 0).
      *
      * These pattern points define this coordinate system:
-     * ![Image with axes drawn](images/singlemarkersaxes2.jpg)
+     * ![Image with axes drawn](tutorials/images/singlemarkersaxes2.jpg)
      *
      * These pattern dots are convenient to use with a chessboard/ChArUco board.
      */
     ARUCO_CW_TOP_LEFT_CORNER
 };
 
 /** @brief Pose estimation parameters
- * @param pattern Defines center this system and axes direction (default PatternPos::ARUCO_CCW_CENTER).
+ *
+ * @param pattern Defines center this system and axes direction (default PatternPositionType::ARUCO_CCW_CENTER).
  * @param useExtrinsicGuess Parameter used for SOLVEPNP_ITERATIVE. If true (1), the function uses the provided
  * rvec and tvec values as initial approximations of the rotation and translation vectors, respectively, and further
  * optimizes them (default false).
  * @param solvePnPMethod Method for solving a PnP problem: see @ref calib3d_solvePnP_flags (default SOLVEPNP_ITERATIVE).
- * @sa PatternPos, solvePnP(), @ref tutorial_aruco_detection
+ * @sa PatternPositionType, solvePnP(), check tutorial_aruco_detection in aruco contrib
  */
-struct CV_EXPORTS_W EstimateParameters {
-    CV_PROP_RW PatternPos pattern;
+struct CV_EXPORTS_W_SIMPLE EstimateParameters {
+    CV_PROP_RW PatternPositionType pattern;
     CV_PROP_RW bool useExtrinsicGuess;
-    CV_PROP_RW SolvePnPMethod solvePnPMethod;
+    CV_PROP_RW int solvePnPMethod;
 
-    EstimateParameters(): pattern(ARUCO_CCW_CENTER), useExtrinsicGuess(false),
-                          solvePnPMethod(SOLVEPNP_ITERATIVE) {}
-
-    CV_WRAP static Ptr<EstimateParameters> create() {
-        return makePtr<EstimateParameters>();
-    }
+    CV_WRAP EstimateParameters();
 };
 
-
-/**
- * @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
- * @param estimateParameters set the origin of coordinate system and the coordinates of the four corners of the marker
- * (default estimateParameters.pattern = PatternPos::ARUCO_CCW_CENTER, estimateParameters.useExtrinsicGuess = false,
- * estimateParameters.solvePnPMethod = SOLVEPNP_ITERATIVE).
- *
- * 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 coordinate system is centered on the middle (by default) or on the top-left corner of the marker,
- * with the Z axis perpendicular to the marker plane.
- * estimateParameters defines the coordinates of the four corners of the marker in its own coordinate system (by default) are:
- * (-markerLength/2, markerLength/2, 0), (markerLength/2, markerLength/2, 0),
- * (markerLength/2, -markerLength/2, 0), (-markerLength/2, -markerLength/2, 0)
- * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
- * @sa @ref tutorial_aruco_detection
- * @sa EstimateParameters
- * @sa PatternPos
- */
-CV_EXPORTS_W void estimatePoseSingleMarkers(InputArrayOfArrays corners, float markerLength,
-                                            InputArray cameraMatrix, InputArray distCoeffs,
-                                            OutputArray rvecs, OutputArray tvecs, OutputArray objPoints = noArray(),
-                                            const Ptr<EstimateParameters>& estimateParameters = EstimateParameters::create());
-
-/**
- * @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.
- * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
- */
-CV_EXPORTS_W int estimatePoseBoard(InputArrayOfArrays corners, InputArray ids, const Ptr<Board> &board,
-                                   InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec,
-                                   InputOutputArray tvec, bool useExtrinsicGuess = false);
-
-/**
- * @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);
-
 /**
  * @brief Calibrate a camera using aruco markers
  *
@@ -203,29 +113,6 @@ CV_EXPORTS_W double calibrateCameraAruco(InputArrayOfArrays corners, InputArray
                                          const TermCriteria& criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS,
                                                                                      30, DBL_EPSILON));
 
-/**
- * @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.
- * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
- */
-CV_EXPORTS_W bool estimatePoseCharucoBoard(InputArray charucoCorners, InputArray charucoIds,
-                                           const Ptr<CharucoBoard> &board, InputArray cameraMatrix,
-                                           InputArray distCoeffs, InputOutputArray rvec,
-                                           InputOutputArray tvec, bool useExtrinsicGuess = false);
 
 /**
  * @brief Calibrate a camera using Charuco corners