Merge branch 4.x

Replace deprecated tostring() with tobytes()

.github/workflows/PR-5.x.yaml

@@ -1,9 +1,9 @@
-name: PR:4.x
+name: PR:5.x
 
 on:
   pull_request:
     branches:
-      - 4.x
+      - 5.x
 
 jobs:
   Linux:
@@ -12,23 +12,19 @@ jobs:
       workflow_branch: main
 
   Ubuntu2004-ARM64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-ARM64.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-ARM64.yaml@main
 
   Ubuntu2004-x64-CUDA:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-U20-Cuda.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-U20-Cuda.yaml@main
 
   Windows10-x64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-W10.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-W10.yaml@main
 
   macOS-ARM64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-macOS-ARM64.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-macOS-ARM64.yaml@main
 
   macOS-X64:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-macOS-x86_64.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-macOS-x86_64.yaml@main
 
   Linux-RISC-V-Clang:
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-RISCV.yaml@main
-
-  openEuler2203-x64:
-    if: "${{ contains(github.event.pull_request.labels.*.name, 'category: cann') }}"
-    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-4.x-O22-CANN.yaml@main
+    uses: opencv/ci-gha-workflow/.github/workflows/OCV-Contrib-PR-5.x-RISCV.yaml@main

modules/aruco/CMakeLists.txt

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

modules/aruco/README.md

@@ -1,17 +0,0 @@
-ArUco Marker Detection
-======================
-
-**ArUco**
-
-![markers](https://github.com/opencv/opencv_contrib/assets/810997/8d587456-f27f-49e4-9540-28a0477d43fc)
-
-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**
-
-![screen_charuco](https://github.com/opencv/opencv_contrib/assets/810997/64610da1-ee06-406c-a19b-006b02ac44fd)
-
-
-ArUco markers were improved by interspersing them inside a checkerboard called ChArUco. Checkerboard corner intersections 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".

modules/aruco/doc/aruco.bib

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

modules/aruco/include/opencv2/aruco.hpp

@@ -1,103 +0,0 @@
-// 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
-
-#include "opencv2/objdetect/aruco_detector.hpp"
-#include "opencv2/aruco/aruco_calib.hpp"
-
-namespace cv {
-namespace aruco {
-
-/**
- * @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 = makePtr<DetectorParameters>(),
-                                OutputArrayOfArrays rejectedImgPoints = noArray());
-
-/** @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 = 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 Board::matchImagePoints and 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.
- * @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
- * @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);
-
-//! @}
-
-}
-}
-
-#endif

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

@@ -1,180 +0,0 @@
-// 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/objdetect/aruco_board.hpp>
-
-namespace cv {
-namespace aruco {
-
-//! @addtogroup aruco
-//! @{
-
-/** @brief rvec/tvec define the right handed coordinate system of the marker.
- *
- * 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.
- *
- * @deprecated Use Board::matchImagePoints and cv::solvePnP
- *
- * @sa estimatePoseSingleMarkers()
- */
-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).
-     */
-    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 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 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).
- *
- * @deprecated Use Board::matchImagePoints and cv::solvePnP
- *
- * @sa PatternPositionType, solvePnP()
- */
-struct CV_EXPORTS_W_SIMPLE EstimateParameters {
-    CV_PROP_RW PatternPositionType pattern;
-    CV_PROP_RW bool useExtrinsicGuess;
-    CV_PROP_RW int solvePnPMethod;
-
-    CV_WRAP EstimateParameters();
-};
-
-/**
- * @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.
- *
- * @deprecated Use Board::matchImagePoints and cv::solvePnP
- */
-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,
-                            const TermCriteria& criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
-
-/** @overload
- * @brief It's the same function as #calibrateCameraAruco but without calibration error estimation.
- * @deprecated Use Board::matchImagePoints and cv::solvePnP
- */
-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,
-                                         const TermCriteria& criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS,
-                                                                                     30, DBL_EPSILON));
-
-
-/**
- * @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.
- *
- * @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
- */
-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, const TermCriteria& criteria = TermCriteria(
-                              TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON));
-
-/**
- * @brief It's the same function as #calibrateCameraCharuco but without calibration error estimation.
- *
- * @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
- */
-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,
-                                           const TermCriteria& criteria=TermCriteria(TermCriteria::COUNT +
-                                                                 TermCriteria::EPS, 30, DBL_EPSILON));
-//! @}
-
-}
-}
-#endif

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

@@ -1,110 +0,0 @@
-// 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_CHARUCO_HPP
-#define OPENCV_CHARUCO_HPP
-
-#include <opencv2/core.hpp>
-#include <vector>
-#include <opencv2/aruco.hpp>
-#include <opencv2/objdetect/charuco_detector.hpp>
-#include <opencv2/aruco/aruco_calib.hpp>
-
-
-namespace cv {
-namespace aruco {
-
-//! @addtogroup aruco
-//! @{
-
-/**
- * @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.
- *
- * @deprecated Use CharucoDetector::detectBoard
- */
-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 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.
- * @param dictionary dictionary of markers indicating the type of markers.
- *
- * 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 less accurate.
- *
- * @deprecated Use CharucoDetector::detectDiamonds
- */
-CV_EXPORTS_W void detectCharucoDiamond(InputArray image, InputArrayOfArrays markerCorners,
-                                       InputArray markerIds, float squareMarkerLengthRate,
-                                       OutputArrayOfArrays diamondCorners, OutputArray diamondIds,
-                                       InputArray cameraMatrix = noArray(),
-                                       InputArray distCoeffs = noArray(),
-                                       Ptr<Dictionary> dictionary = makePtr<Dictionary>
-                                               (getPredefinedDictionary(PredefinedDictionaryType::DICT_4X4_50)));
-
-
-/**
- * @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.
- *
- * @deprecated Use CharucoBoard::generateImage()
- */
-CV_EXPORTS_W void drawCharucoDiamond(const Ptr<Dictionary> &dictionary, Vec4i ids, int squareLength,
-                                     int markerLength, OutputArray img, int marginSize = 0,
-                                     int borderBits = 1);
-
-//! @}
-}
-}
-
-#endif

modules/aruco/misc/objc/gen_dict.json

@@ -1,10 +0,0 @@
-{
-    "AdditionalImports" : {
-        "*" : [ "\"aruco.hpp\"", "\"aruco/charuco.hpp\"" ]
-    },
-    "func_arg_fix" : {
-        "Aruco" : {
-            "estimatePoseSingleMarkers" : { "estimateParameters" : {"defval" : "cv::makePtr<cv::aruco::EstimateParameters>()"} }
-        }
-    }
-}

modules/aruco/misc/pattern_generator/MarkerPrinterGUI.py

@@ -1,565 +0,0 @@
-#!/usr/bin/env python3
-
-# SPDX-License-Identifier: BSD-3-Clause
-#
-# Copyright (c) 2019, Josh Chien. All rights reserved.
-
-from MarkerPrinter import *
-
-import tkinter as tk
-from tkinter import ttk, filedialog, messagebox
-
-import time
-
-import PIL.Image
-import PIL.ImageTk
-
-class MarkerPrinterGUI:
-
-    def VisDPI(self, shape):
-        scale0 = float(self.displayShape[0]) / float(shape[0])
-        scale1 = float(self.displayShape[1]) / float(shape[1])
-        if(scale0 > scale1):
-            return scale1 * 96.0
-        else:
-            return scale0 * 96.0
-
-    def OnShowingHelpGithub(self):
-        messagebox.showinfo("Github",
-            "https://github.com/dogod621/OpenCVMarkerPrinter")
-
-    def OnCloseWindow(self):
-        if(self.window is not None):
-            if messagebox.askokcancel("Quit", "Do you want to quit?"):
-                self.window.destroy()
-                self.window = None
-
-    def OnSelectCharucoMarkerDictionary(self, pDictName):
-        self.charucoMarkerDictionaryStr.set(pDictName)
-
-    def __SaveMarker(GenMarkerImageCallback, *args, **kwargs):
-
-        if(kwargs.get("subSize",None) is not None):
-            subSizeX, subSizeY = kwargs["subSize"]
-
-            kwargs["subSize"] = None
-
-            if(subSizeX > 0):
-                if(subSizeY > 0):
-                    kwargs["subSize"] = (subSizeX, subSizeY)
-                else:
-                    kwargs["subSize"] = (subSizeX, sizeY)
-            else:
-                if(subSizeY > 0):
-                    kwargs["subSize"] = (sizeX, subSizeY)
-                else:
-                    kwargs["subSize"] = None
-
-        try:
-            askFileName = filedialog.asksaveasfilename(initialdir = os.path.abspath("./"), title = "Output", filetypes = (\
-                ("scalable vector graphics files","*.svg"), \
-                ("portable document format files","*.pdf"), \
-                ("post script files","*.ps")),
-                defaultextension="*.*")
-
-            if (askFileName):
-                GenMarkerImageCallback(askFileName, *args, **kwargs)
-
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Save marker failed")
-            return
-
-    def OnPreviewOrSaveCharucoMarker(self, askSave = False):
-        try:
-            sizeX = int(self.charucoMarkerChessboardSizeXStr.get())
-            sizeY = int(self.charucoMarkerChessboardSizeYStr.get())
-            squareLength = float(self.charucoMarkerSquareLengthStr.get())
-            markerLength = float(self.charucoMarkerMarkerLengthStr.get())
-            borderBits = int(self.charucoMarkerBorderBitsStr.get())
-            dictionary = self.charucoMarkerDictionaryStr.get()
-            subSizeX = int(self.charucoMarkerSaveSubSizeXStr.get())
-            subSizeY = int(self.charucoMarkerSaveSubSizeYStr.get())
-            pageBorderX = float(self.charucoMarkerSavePageBorderXStr.get())
-            pageBorderY = float(self.charucoMarkerSavePageBorderYStr.get())
-        except ValueError as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Enter invalid parameters")
-            return
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Fail to get parameters")
-            return
-
-        # Preview
-        try:
-            dpi = self.VisDPI(((sizeY * squareLength + pageBorderY * 2) * MarkerPrinter.ptPerMeter, (sizeX * squareLength + pageBorderX * 2) * MarkerPrinter.ptPerMeter))
-            tkImage = PIL.ImageTk.PhotoImage(image = MarkerPrinter.PreviewCharucoMarkerImage(dictionary, (sizeX, sizeY), squareLength, markerLength, borderBits=borderBits, pageBorder = (pageBorderX, pageBorderY), dpi=dpi))
-            self.charucoMarkerImageLabel.imgtk = tkImage
-            self.charucoMarkerImageLabel.config(image=tkImage)
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "create marker failed")
-            return
-
-        # Save
-        if(askSave):
-            MarkerPrinterGUI.__SaveMarker(MarkerPrinter.GenCharucoMarkerImage, \
-                dictionary, (sizeX, sizeY), squareLength, markerLength, borderBits=borderBits, subSize = (subSizeX, subSizeY), pageBorder = (pageBorderX, pageBorderY))
-
-    def OnPreviewCharucoMarker(self):
-        self.OnPreviewOrSaveCharucoMarker(askSave = False)
-
-    def OnSaveCharucoMarker(self):
-        self.OnPreviewOrSaveCharucoMarker(askSave = True)
-
-    def InitCharucoMarkerTab(self):
-        self.charucoMarkerUIFrame = ttk.Frame(self.charucoMarkerTab)
-        self.charucoMarkerImageTab = ttk.Frame(self.charucoMarkerTab)
-        self.charucoMarkerUIFrame2 = ttk.Frame(self.charucoMarkerTab)
-
-        self.charucoMarkerUIFrame.grid(row=0, column=0, sticky = tk.NSEW)
-        self.charucoMarkerImageTab.grid(row=1, column=0, sticky = tk.NSEW)
-        self.charucoMarkerUIFrame2.grid(row=2, column=0, sticky = tk.NSEW)
-
-        self.charucoMarkerImageLabel = tk.Label(self.charucoMarkerImageTab)
-        self.charucoMarkerImageLabel.grid(row=0, column=0, sticky = tk.NSEW)
-
-        tk.Label(self.charucoMarkerUIFrame, text="dictionary").grid(row=0, column=0, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame, text="chessboardSizeX").grid(row=0, column=1, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame, text="chessboardSizeY").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame, text="squareLength (Unit: Meter)").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame, text="markerLength (Unit: Meter)").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame, text="borderBits").grid(row=0, column=5, sticky = tk.NSEW)
-
-        self.charucoMarkerDictionaryStr = tk.StringVar()
-        self.charucoMarkerChessboardSizeXStr = tk.StringVar()
-        self.charucoMarkerChessboardSizeXStr.set("16")
-        self.charucoMarkerChessboardSizeYStr = tk.StringVar()
-        self.charucoMarkerChessboardSizeYStr.set("9")
-        self.charucoMarkerSquareLengthStr = tk.StringVar()
-        self.charucoMarkerSquareLengthStr.set("0.09")
-        self.charucoMarkerMarkerLengthStr = tk.StringVar()
-        self.charucoMarkerMarkerLengthStr.set("0.07")
-        self.charucoMarkerBorderBitsStr = tk.StringVar()
-        self.charucoMarkerBorderBitsStr.set("1")
-
-        self.charucoMarkerDictionaryMenue = tk.OptionMenu(self.charucoMarkerUIFrame, self.charucoMarkerDictionaryStr, "DICT_ARUCO_ORIGINAL", command = self.OnSelectCharucoMarkerDictionary)
-        self.charucoMarkerDictionaryMenue.grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame, textvariable=self.charucoMarkerChessboardSizeXStr).grid(row=1, column=1, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame, textvariable=self.charucoMarkerChessboardSizeYStr).grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame, textvariable=self.charucoMarkerSquareLengthStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame, textvariable=self.charucoMarkerMarkerLengthStr).grid(row=1, column=4, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame, textvariable=self.charucoMarkerBorderBitsStr).grid(row=1, column=5, sticky = tk.NSEW)
-
-        tk.Button(self.charucoMarkerUIFrame2, text = "Preview", command = self.OnPreviewCharucoMarker).grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Button(self.charucoMarkerUIFrame2, text = "Save", command = self.OnSaveCharucoMarker).grid(row=1, column=1, sticky = tk.NSEW)
-
-        tk.Label(self.charucoMarkerUIFrame2, text="Save options:").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="(set 0 as disable)").grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="subSizeX").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="subSizeY").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="Divide to chunks, chunk sizeX").grid(row=2, column=3, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="Divide to chunks, chunk sizeY").grid(row=2, column=4, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="pageBorderX (Unit: Meter)").grid(row=0, column=5, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="pageBorderY (Unit: Meter)").grid(row=0, column=6, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="Border or page").grid(row=2, column=5, sticky = tk.NSEW)
-        tk.Label(self.charucoMarkerUIFrame2, text="Border or page").grid(row=2, column=6, sticky = tk.NSEW)
-
-        self.charucoMarkerSaveSubSizeXStr = tk.StringVar()
-        self.charucoMarkerSaveSubSizeXStr.set("0")
-        self.charucoMarkerSaveSubSizeYStr = tk.StringVar()
-        self.charucoMarkerSaveSubSizeYStr.set("0")
-        self.charucoMarkerSavePageBorderXStr = tk.StringVar()
-        self.charucoMarkerSavePageBorderXStr.set("0.02")
-        self.charucoMarkerSavePageBorderYStr = tk.StringVar()
-        self.charucoMarkerSavePageBorderYStr.set("0.02")
-
-        tk.Entry(self.charucoMarkerUIFrame2, textvariable=self.charucoMarkerSaveSubSizeXStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame2, textvariable=self.charucoMarkerSaveSubSizeYStr).grid(row=1, column=4, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame2, textvariable=self.charucoMarkerSavePageBorderXStr).grid(row=1, column=5, sticky = tk.NSEW)
-        tk.Entry(self.charucoMarkerUIFrame2, textvariable=self.charucoMarkerSavePageBorderYStr).grid(row=1, column=6, sticky = tk.NSEW)
-
-        self.charucoMarkerDictionaryMenue['menu'].delete(0, 'end')
-        for dictName in self.dictList:
-            self.charucoMarkerDictionaryMenue['menu'].add_command(label=dictName, command=tk._setit(self.charucoMarkerDictionaryStr, dictName, self.OnSelectCharucoMarkerDictionary))
-
-        self.OnSelectCharucoMarkerDictionary("DICT_ARUCO_ORIGINAL")
-
-    def OnSelectArucoGridMarkerDictionary(self, pDictName):
-        self.arucoGridMarkerDictionaryStr.set(pDictName)
-
-    def OnPreviewOrSaveArucoGridMarker(self, askSave = False):
-        try:
-            markersX = int(self.arucoGridMarkerMarkersXStr.get())
-            markersY = int(self.arucoGridMarkerMarkersYStr.get())
-            markerLength = float(self.arucoGridMarkerMarkerLengthStr.get())
-            markerSeparation = float(self.arucoGridMarkerMarkerSeparationStr.get())
-            borderBits = int(self.arucoGridMarkerBorderBitsStr.get())
-            firstMarker = int(self.arucoGridMarkerFirstMarkerStr.get())
-            dictionary = self.arucoGridMarkerDictionaryStr.get()
-            subSizeX = int(self.arucoGridMarkerSaveSubSizeXStr.get())
-            subSizeY = int(self.arucoGridMarkerSaveSubSizeYStr.get())
-            pageBorderX = float(self.arucoGridMarkerSavePageBorderXStr.get())
-            pageBorderY = float(self.arucoGridMarkerSavePageBorderYStr.get())
-        except ValueError as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Enter invalid parameters")
-            return
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Fail to get parameters")
-            return
-
-        # Preview
-        try:
-            dpi=self.VisDPI(((markersY * markerLength + (markersY  - 1) * markerSeparation + pageBorderY * 2) * MarkerPrinter.ptPerMeter, (markersX * markerLength + (markersX  - 1) * markerSeparation + pageBorderX * 2) * MarkerPrinter.ptPerMeter))
-            tkImage = PIL.ImageTk.PhotoImage(image = MarkerPrinter.PreviewArucoGridMarkerImage(dictionary, (markersX, markersY), markerLength, markerSeparation, firstMarker, borderBits=borderBits, pageBorder = (pageBorderX, pageBorderY), dpi=dpi))
-            self.arucoGridMarkerImageLabel.imgtk = tkImage
-            self.arucoGridMarkerImageLabel.config(image=tkImage)
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "create marker failed")
-            return
-
-        # Save
-        if(askSave):
-            MarkerPrinterGUI.__SaveMarker(MarkerPrinter.GenArucoGridMarkerImage, \
-                dictionary, (markersX, markersY), markerLength, markerSeparation, firstMarker, borderBits=borderBits, subSize = (subSizeX, subSizeY), pageBorder = (pageBorderX, pageBorderY))
-
-    def OnPreviewArucoGridMarker(self):
-        self.OnPreviewOrSaveArucoGridMarker(askSave = False)
-
-    def OnSaveArucoGridMarker(self):
-        self.OnPreviewOrSaveArucoGridMarker(askSave = True)
-
-    def InitArucoGridMarkerTab(self):
-        self.arucoGridMarkerUIFrame = ttk.Frame(self.arucoGridMarkerTab)
-        self.arucoGridMarkerImageTab = ttk.Frame(self.arucoGridMarkerTab)
-        self.arucoGridMarkerUIFrame2 = ttk.Frame(self.arucoGridMarkerTab)
-
-        self.arucoGridMarkerUIFrame.grid(row=0, column=0, sticky = tk.NSEW)
-        self.arucoGridMarkerImageTab.grid(row=1, column=0, sticky = tk.NSEW)
-        self.arucoGridMarkerUIFrame2.grid(row=2, column=0, sticky = tk.NSEW)
-
-        self.arucoGridMarkerImageLabel = tk.Label(self.arucoGridMarkerImageTab)
-        self.arucoGridMarkerImageLabel.grid(row=0, column=0, sticky = tk.NSEW)
-
-        tk.Label(self.arucoGridMarkerUIFrame, text="dictionary").grid(row=0, column=0, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="markersX").grid(row=0, column=1, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="markersY").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="markerLength (Unit: Meter)").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="markerSeparation (Unit: Meter)").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="firstMarker").grid(row=0, column=5, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame, text="borderBits").grid(row=0, column=6, sticky = tk.NSEW)
-
-        self.arucoGridMarkerDictionaryStr = tk.StringVar()
-        self.arucoGridMarkerMarkersXStr = tk.StringVar()
-        self.arucoGridMarkerMarkersXStr.set("16")
-        self.arucoGridMarkerMarkersYStr = tk.StringVar()
-        self.arucoGridMarkerMarkersYStr.set("9")
-        self.arucoGridMarkerMarkerLengthStr = tk.StringVar()
-        self.arucoGridMarkerMarkerLengthStr.set("0.07")
-        self.arucoGridMarkerMarkerSeparationStr = tk.StringVar()
-        self.arucoGridMarkerMarkerSeparationStr.set("0.02")
-        self.arucoGridMarkerFirstMarkerStr = tk.StringVar()
-        self.arucoGridMarkerFirstMarkerStr.set("0")
-        self.arucoGridMarkerBorderBitsStr = tk.StringVar()
-        self.arucoGridMarkerBorderBitsStr.set("1")
-
-        self.arucoGridMarkerDictionaryMenue = tk.OptionMenu(self.arucoGridMarkerUIFrame, self.arucoGridMarkerDictionaryStr, "DICT_ARUCO_ORIGINAL", command = self.OnSelectArucoGridMarkerDictionary)
-        self.arucoGridMarkerDictionaryMenue.grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerMarkersXStr).grid(row=1, column=1, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerMarkersYStr).grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerMarkerLengthStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerMarkerSeparationStr).grid(row=1, column=4, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerFirstMarkerStr).grid(row=1, column=5, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame, textvariable=self.arucoGridMarkerBorderBitsStr).grid(row=1, column=6, sticky = tk.NSEW)
-
-        tk.Button(self.arucoGridMarkerUIFrame2, text = "Preview", command = self.OnPreviewArucoGridMarker).grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Button(self.arucoGridMarkerUIFrame2, text = "Save", command = self.OnSaveArucoGridMarker).grid(row=1, column=1, sticky = tk.NSEW)
-
-        tk.Label(self.arucoGridMarkerUIFrame2, text="Save options:").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="(set 0 as disable)").grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="subSizeX").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="subSizeY").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="Divide to chunks, chunk sizeX").grid(row=2, column=3, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="Divide to chunks, chunk sizeY").grid(row=2, column=4, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="pageBorderX (Unit: Meter)").grid(row=0, column=5, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="pageBorderY (Unit: Meter)").grid(row=0, column=6, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="Border or page").grid(row=2, column=5, sticky = tk.NSEW)
-        tk.Label(self.arucoGridMarkerUIFrame2, text="Border or page").grid(row=2, column=6, sticky = tk.NSEW)
-
-        self.arucoGridMarkerSaveSubSizeXStr = tk.StringVar()
-        self.arucoGridMarkerSaveSubSizeXStr.set("0")
-        self.arucoGridMarkerSaveSubSizeYStr = tk.StringVar()
-        self.arucoGridMarkerSaveSubSizeYStr.set("0")
-        self.arucoGridMarkerSavePageBorderXStr = tk.StringVar()
-        self.arucoGridMarkerSavePageBorderXStr.set("0.02")
-        self.arucoGridMarkerSavePageBorderYStr = tk.StringVar()
-        self.arucoGridMarkerSavePageBorderYStr.set("0.02")
-
-        tk.Entry(self.arucoGridMarkerUIFrame2, textvariable=self.arucoGridMarkerSaveSubSizeXStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame2, textvariable=self.arucoGridMarkerSaveSubSizeYStr).grid(row=1, column=4, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame2, textvariable=self.arucoGridMarkerSavePageBorderXStr).grid(row=1, column=5, sticky = tk.NSEW)
-        tk.Entry(self.arucoGridMarkerUIFrame2, textvariable=self.arucoGridMarkerSavePageBorderYStr).grid(row=1, column=6, sticky = tk.NSEW)
-
-        self.arucoGridMarkerDictionaryMenue['menu'].delete(0, 'end')
-        for dictName in self.dictList:
-            self.arucoGridMarkerDictionaryMenue['menu'].add_command(label=dictName, command=tk._setit(self.arucoGridMarkerDictionaryStr, dictName, self.OnSelectArucoGridMarkerDictionary))
-
-        self.OnSelectArucoGridMarkerDictionary("DICT_ARUCO_ORIGINAL")
-
-    def OnSelectArucoMarkerDictionary(self, pDictName):
-        self.arucoMarkerDictionaryStr.set(pDictName)
-
-    def OnPreviewOrSaveArucoMarker(self, askSave = False):
-        try:
-            markerID = int(self.arucoMarkerMarkerIDStr.get())
-            markerLength = float(self.arucoMarkerMarkerLengthStr.get())
-            borderBits = int(self.arucoMarkerBorderBitsStr.get())
-            dictionary = self.arucoMarkerDictionaryStr.get()
-            pageBorderX = float(self.arucoMarkerSavePageBorderXStr.get())
-            pageBorderY = float(self.arucoMarkerSavePageBorderYStr.get())
-        except ValueError as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Enter invalid parameters")
-            return
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Fail to get parameters")
-            return
-
-        # Preview
-        try:
-            dpi=self.VisDPI(((markerLength  + pageBorderY * 2) * MarkerPrinter.ptPerMeter, (markerLength + pageBorderX * 2) * MarkerPrinter.ptPerMeter))
-            tkImage = PIL.ImageTk.PhotoImage(image = MarkerPrinter.PreviewArucoMarkerImage(dictionary, markerID, markerLength, borderBits=borderBits, pageBorder = (pageBorderX, pageBorderY), dpi=dpi))
-            self.arucoMarkerImageLabel.imgtk = tkImage
-            self.arucoMarkerImageLabel.config(image=tkImage)
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "create marker failed")
-            return
-
-        # Save
-        if(askSave):
-            MarkerPrinterGUI.__SaveMarker(MarkerPrinter.GenArucoMarkerImage, \
-                dictionary, markerID, markerLength, borderBits=borderBits, pageBorder = (pageBorderX, pageBorderY))
-
-    def OnPreviewArucoMarker(self):
-        self.OnPreviewOrSaveArucoMarker(askSave = False)
-
-    def OnSaveArucoMarker(self):
-        self.OnPreviewOrSaveArucoMarker(askSave = True)
-
-    def InitArucoMarkerTab(self):
-        self.arucoMarkerUIFrame = ttk.Frame(self.arucoMarkerTab)
-        self.arucoMarkerImageTab = ttk.Frame(self.arucoMarkerTab)
-        self.arucoMarkerUIFrame2 = ttk.Frame(self.arucoMarkerTab)
-
-        self.arucoMarkerUIFrame.grid(row=0, column=0, sticky = tk.NSEW)
-        self.arucoMarkerImageTab.grid(row=1, column=0, sticky = tk.NSEW)
-        self.arucoMarkerUIFrame2.grid(row=2, column=0, sticky = tk.NSEW)
-
-        self.arucoMarkerImageLabel = tk.Label(self.arucoMarkerImageTab)
-        self.arucoMarkerImageLabel.grid(row=0, column=0, sticky = tk.NSEW)
-
-        tk.Label(self.arucoMarkerUIFrame, text="dictionary").grid(row=0, column=0, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame, text="markerID").grid(row=0, column=1, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame, text="markerLength (Unit: Meter)").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame, text="borderBits").grid(row=0, column=3, sticky = tk.NSEW)
-
-        self.arucoMarkerDictionaryStr = tk.StringVar()
-        self.arucoMarkerMarkerIDStr = tk.StringVar()
-        self.arucoMarkerMarkerIDStr.set("0")
-        self.arucoMarkerMarkerLengthStr = tk.StringVar()
-        self.arucoMarkerMarkerLengthStr.set("0.07")
-        self.arucoMarkerBorderBitsStr = tk.StringVar()
-        self.arucoMarkerBorderBitsStr.set("1")
-
-        self.arucoMarkerDictionaryMenue = tk.OptionMenu(self.arucoMarkerUIFrame, self.arucoMarkerDictionaryStr, "DICT_ARUCO_ORIGINAL", command = self.OnSelectArucoMarkerDictionary)
-        self.arucoMarkerDictionaryMenue.grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Entry(self.arucoMarkerUIFrame, textvariable=self.arucoMarkerMarkerIDStr).grid(row=1, column=1, sticky = tk.NSEW)
-        tk.Entry(self.arucoMarkerUIFrame, textvariable=self.arucoMarkerMarkerLengthStr).grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Entry(self.arucoMarkerUIFrame, textvariable=self.arucoMarkerBorderBitsStr).grid(row=1, column=3, sticky = tk.NSEW)
-
-        tk.Button(self.arucoMarkerUIFrame2, text = "Preview", command = self.OnPreviewArucoMarker).grid(row=0, column=0, sticky = tk.NSEW)
-        tk.Button(self.arucoMarkerUIFrame2, text = "Save", command = self.OnSaveArucoMarker).grid(row=0, column=1, sticky = tk.NSEW)
-
-        tk.Label(self.arucoMarkerUIFrame2, text="Save options:").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame2, text="(set 0 as disable)").grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame2, text="pageBorderX (Unit: Meter)").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame2, text="pageBorderY (Unit: Meter)").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame2, text="Border or page").grid(row=2, column=3, sticky = tk.NSEW)
-        tk.Label(self.arucoMarkerUIFrame2, text="Border or page").grid(row=2, column=4, sticky = tk.NSEW)
-
-        self.arucoMarkerSavePageBorderXStr = tk.StringVar()
-        self.arucoMarkerSavePageBorderXStr.set("0.02")
-        self.arucoMarkerSavePageBorderYStr = tk.StringVar()
-        self.arucoMarkerSavePageBorderYStr.set("0.02")
-
-        tk.Entry(self.arucoMarkerUIFrame2, textvariable=self.arucoMarkerSavePageBorderXStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.arucoMarkerUIFrame2, textvariable=self.arucoMarkerSavePageBorderYStr).grid(row=1, column=4, sticky = tk.NSEW)
-
-        self.arucoMarkerDictionaryMenue['menu'].delete(0, 'end')
-        for dictName in self.dictList:
-            self.arucoMarkerDictionaryMenue['menu'].add_command(label=dictName, command=tk._setit(self.arucoMarkerDictionaryStr, dictName, self.OnSelectArucoMarkerDictionary))
-
-        self.OnSelectArucoMarkerDictionary("DICT_ARUCO_ORIGINAL")
-
-    def OnPreviewOrSaveChessMarker(self, askSave = False):
-        try:
-            sizeX = int(self.chessMarkerChessboardSizeXStr.get())
-            sizeY = int(self.chessMarkerChessboardSizeYStr.get())
-            squareLength = float(self.chessMarkerSquareLengthStr.get())
-            subSizeX = int(self.chessMarkerSaveSubSizeXStr.get())
-            subSizeY = int(self.chessMarkerSaveSubSizeYStr.get())
-            pageBorderX = float(self.chessMarkerSavePageBorderXStr.get())
-            pageBorderY = float(self.chessMarkerSavePageBorderYStr.get())
-        except ValueError as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Enter invalid parameters")
-            return
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "Fail to get parameters")
-            return
-
-        # Preview
-        try:
-            dpi=self.VisDPI(((sizeY * squareLength + pageBorderY * 2) * MarkerPrinter.ptPerMeter, (sizeX * squareLength + pageBorderX * 2) * MarkerPrinter.ptPerMeter))
-            tkImage = PIL.ImageTk.PhotoImage(image = MarkerPrinter.PreviewChessMarkerImage((sizeX, sizeY), squareLength, pageBorder = (pageBorderX, pageBorderY), dpi=dpi))
-            self.chessMarkerImageLabel.imgtk = tkImage
-            self.chessMarkerImageLabel.config(image=tkImage)
-        except Exception as e:
-            warnings.warn(str(e))
-            messagebox.showinfo("Error", "create marker failed")
-            return
-
-        # Save
-        if(askSave):
-            MarkerPrinterGUI.__SaveMarker(MarkerPrinter.GenChessMarkerImage, \
-                (sizeX, sizeY), squareLength, subSize = (subSizeX, subSizeY), pageBorder = (pageBorderX, pageBorderY))
-
-    def OnPreviewChessMarker(self):
-        self.OnPreviewOrSaveChessMarker(askSave = False)
-
-    def OnSaveChessMarker(self):
-        self.OnPreviewOrSaveChessMarker(askSave = True)
-
-    def InitChessMarkerTab(self):
-        self.chessMarkerUIFrame = ttk.Frame(self.chessMarkerTab)
-        self.chessMarkerImageTab = ttk.Frame(self.chessMarkerTab)
-        self.chessMarkerUIFrame2 = ttk.Frame(self.chessMarkerTab)
-
-        self.chessMarkerUIFrame.grid(row=0, column=0, sticky = tk.NSEW)
-        self.chessMarkerImageTab.grid(row=1, column=0, sticky = tk.NSEW)
-        self.chessMarkerUIFrame2.grid(row=2, column=0, sticky = tk.NSEW)
-
-        self.chessMarkerImageLabel = tk.Label(self.chessMarkerImageTab)
-        self.chessMarkerImageLabel.grid(row=0, column=0, sticky = tk.NSEW)
-
-        tk.Label(self.chessMarkerUIFrame, text="chessboardSizeX").grid(row=0, column=0, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame, text="chessboardSizeY").grid(row=0, column=1, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame, text="squareLength (Unit: Meter)").grid(row=0, column=2, sticky = tk.NSEW)
-
-        self.chessMarkerChessboardSizeXStr = tk.StringVar()
-        self.chessMarkerChessboardSizeXStr.set("16")
-        self.chessMarkerChessboardSizeYStr = tk.StringVar()
-        self.chessMarkerChessboardSizeYStr.set("9")
-        self.chessMarkerSquareLengthStr = tk.StringVar()
-        self.chessMarkerSquareLengthStr.set("0.09")
-
-        tk.Entry(self.chessMarkerUIFrame, textvariable=self.chessMarkerChessboardSizeXStr).grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Entry(self.chessMarkerUIFrame, textvariable=self.chessMarkerChessboardSizeYStr).grid(row=1, column=1, sticky = tk.NSEW)
-        tk.Entry(self.chessMarkerUIFrame, textvariable=self.chessMarkerSquareLengthStr).grid(row=1, column=2, sticky = tk.NSEW)
-
-        tk.Button(self.chessMarkerUIFrame2, text = "Preview", command = self.OnPreviewChessMarker).grid(row=1, column=0, sticky = tk.NSEW)
-        tk.Button(self.chessMarkerUIFrame2, text = "Save", command = self.OnSaveChessMarker).grid(row=1, column=1, sticky = tk.NSEW)
-
-        tk.Label(self.chessMarkerUIFrame2, text="Save options:").grid(row=0, column=2, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="(set 0 as disable)").grid(row=1, column=2, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="subSizeX").grid(row=0, column=3, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="subSizeY").grid(row=0, column=4, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="Divide to chunks, chunk sizeX").grid(row=2, column=3, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="Divide to chunks, chunk sizeY").grid(row=2, column=4, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="pageBorderX (Unit: Meter)").grid(row=0, column=5, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="pageBorderY (Unit: Meter)").grid(row=0, column=6, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="Border or page").grid(row=2, column=5, sticky = tk.NSEW)
-        tk.Label(self.chessMarkerUIFrame2, text="Border or page").grid(row=2, column=6, sticky = tk.NSEW)
-
-        self.chessMarkerSaveSubSizeXStr = tk.StringVar()
-        self.chessMarkerSaveSubSizeXStr.set("0")
-        self.chessMarkerSaveSubSizeYStr = tk.StringVar()
-        self.chessMarkerSaveSubSizeYStr.set("0")
-        self.chessMarkerSavePageBorderXStr = tk.StringVar()
-        self.chessMarkerSavePageBorderXStr.set("0.02")
-        self.chessMarkerSavePageBorderYStr = tk.StringVar()
-        self.chessMarkerSavePageBorderYStr.set("0.02")
-
-        tk.Entry(self.chessMarkerUIFrame2, textvariable=self.chessMarkerSaveSubSizeXStr).grid(row=1, column=3, sticky = tk.NSEW)
-        tk.Entry(self.chessMarkerUIFrame2, textvariable=self.chessMarkerSaveSubSizeYStr).grid(row=1, column=4, sticky = tk.NSEW)
-        tk.Entry(self.chessMarkerUIFrame2, textvariable=self.chessMarkerSavePageBorderXStr).grid(row=1, column=5, sticky = tk.NSEW)
-        tk.Entry(self.chessMarkerUIFrame2, textvariable=self.chessMarkerSavePageBorderYStr).grid(row=1, column=6, sticky = tk.NSEW)
-
-    def Update(self):
-        time.sleep(0)
-        self.window.after(self.delay, self.Update)
-
-    def __init__(self, pDelay=15, pDisplayShape=(int(400), int(1200))):
-        self.delay = pDelay
-        self.displayShape = pDisplayShape
-
-        self.dictList = MarkerPrinter.arucoDictBytesList.keys()
-
-        # GUI
-        self.window = tk.Tk()
-        self.notebook = ttk.Notebook(self.window)
-        self.notebook.grid(row=0, column=0, sticky = tk.NSEW)
-
-        self.window.title("MarkerPrinterGUI")
-        self.window.config(cursor="arrow")
-        self.window.protocol("WM_DELETE_WINDOW", self.OnCloseWindow)
-
-        # Menues
-        self.menu = tk.Menu(self.window)
-        self.helpMenu = tk.Menu(self.menu, tearoff=0)
-        self.menu.add_cascade(label="Help", menu=self.helpMenu)
-        self.helpMenu.add_command(label="Github", command=self.OnShowingHelpGithub)
-        self.helpMenu.add_command(label="DEBUG_LINE_MODE", command=self.On_DEBUG_LINE_MODE)
-        self.helpMenu.add_command(label="DEBUG_BLOCK_MODE", command=self.On_DEBUG_BLOCK_MODE)
-        self.helpMenu.add_command(label="CLOSE_DEBUG_MODE", command=self.On_CLOSE_DEBUG_MODE)
-        self.window.config(menu=self.menu)
-
-        self.charucoMarkerTab = ttk.Frame(self.notebook)
-        self.arucoMarkerTab = ttk.Frame(self.notebook)
-        self.arucoGridMarkerTab = ttk.Frame(self.notebook)
-        self.chessMarkerTab = ttk.Frame(self.notebook)
-
-        self.notebook.add(self.charucoMarkerTab, text='ChArUco Marker')
-        self.notebook.add(self.arucoMarkerTab, text='ArUco Marker')
-        self.notebook.add(self.arucoGridMarkerTab, text='ArUcoGrid Marker')
-        self.notebook.add(self.chessMarkerTab, text='Chessboard Marker')
-
-        self.InitCharucoMarkerTab()
-        self.InitArucoMarkerTab()
-        self.InitArucoGridMarkerTab()
-        self.InitChessMarkerTab()
-
-        self.Update()
-        self.window.mainloop()
-
-    def On_DEBUG_LINE_MODE(self):
-        messagebox.showinfo("Note", "You enabled the debug mode: \"LINE\"")
-        MarkerPrinter.debugMode = "LINE"
-
-    def On_DEBUG_BLOCK_MODE(self):
-        messagebox.showinfo("Note", "You enabled the debug mode: \"BLOCK\"")
-        MarkerPrinter.debugMode = "BLOCK"
-
-    def On_CLOSE_DEBUG_MODE(self):
-        messagebox.showinfo("Note", "You closed the debug mode")
-        MarkerPrinter.debugMode = None
-
-if __name__ == '__main__':
-    MarkerPrinterGUI()

modules/aruco/misc/pattern_generator/README.md

@@ -1,68 +0,0 @@
-# OpenCVMarkerPrinter
-
-## Description
-This small app can save some commonly used opencv markers such as ArUco, ArUcoGrid, Chessboard and ChArUco to vector graphics file. **Supported vector graphics file format: .svg, .pdf and .ps.**
-
-<img src="./doc/images/MarkerPrinterGUI.jpg" height="160" />
-
-### Dependencies
-#### MarkerPrinter
-  * numpy
-  * PIL(Pillow, for image processing)
-  * cairo(for drawing vector graphic)
-  * cairosvg(for svg to png)
-
-#### MarkerPrinterGUI
-  * tkinter(for GUI)
-
-## Tutorial
-#### GUI
-```
-python MarkerPrinterGUI.py
-```
-
-You can switch ArUco, ArUcoGrid, Chessboard and ChArUco mode at the GUI tab, then you can select dictionary from the GUI menu and modify board shape, marker size, border width... etc. at the GUI entry, finally click the preview or save button to show the marker image on the GUI window or save it to file.
-
-#### Command-Line
-##### Print help
-```
-python MarkerPrinter.py
-```
-
-##### Print predefined dictionary list
-```
-python MarkerPrinter.py --list_dictionary
-```
-
-##### Save chessboard
-```
-python MarkerPrinter.py --chess --file "./chess.pdf" --size_x 16 --size_y 9 --square_length 0.09
-```
-
-##### Save ArUco
-```
-python MarkerPrinter.py --aruco --file "./aruco.pdf" --dictionary DICT_ARUCO_ORIGINAL --marker_length 0.07 --marker_id 0 --border_bits 1
-```
-
-##### Save ArUco Grid
-```
-python MarkerPrinter.py --aruco_grid --file "./aruco_grid.pdf" --dictionary DICT_ARUCO_ORIGINAL --size_x 16 --size_y 9 --marker_length 0.07 --marker_separation 0.02 --first_marker 0 --border_bits 1
-```
-
-##### Save ChArUco
-```
-python MarkerPrinter.py --charuco --file "./charuco.pdf" --dictionary DICT_ARUCO_ORIGINAL --size_x 16 --size_y 9 --square_length 0.09 --marker_length 0.07 --border_bits 1
-```
-
-## Useful Options:
-### Divde output to chunks
-If you are using consumer level printer, you will suffer from not able printing too large marker, so just set chunks shape at the GUI subSize entry before saving the marker to files, it will divide output marker to chunks. If you are using command-line interface, just add --sub_size_x x --sub_size_y y as parameters.
-
-### Page border
-If you are printing the image directly, you will need add page border to protect the marker, so just set page border at the GUI pageBorder entry before saving the marker to files. If you are using command-line interface, just add --page_border_x x --page_border_y y as parameters.
-
-### Generate aruco data:
-Although there is a built-in aruco dictionary data, but if you want to update the dictionary(If aruco update predefined dictionary list), just install opencv-python and opencv-contrib-python, and than run
-```
-python MarkerPrinter.py --generate arucoDictBytesList.npz
-```

modules/aruco/misc/python/test/test_aruco.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import os, numpy as np
-
-import cv2 as cv
-
-from tests_common import NewOpenCVTests
-
-class aruco_test(NewOpenCVTests):
-
-    def test_aruco_detect_markers(self):
-        aruco_params = cv.aruco.DetectorParameters()
-        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_250)
-        id = 2
-        marker_size = 100
-        offset = 10
-        img_marker = cv.aruco.generateImageMarker(aruco_dict, id, marker_size, aruco_params.markerBorderBits)
-        img_marker = np.pad(img_marker, pad_width=offset, mode='constant', constant_values=255)
-        gold_corners = np.array([[offset, offset],[marker_size+offset-1.0,offset],
-                                 [marker_size+offset-1.0,marker_size+offset-1.0],
-                                 [offset, marker_size+offset-1.0]], dtype=np.float32)
-        expected_corners, expected_ids, expected_rejected = cv.aruco.detectMarkers(img_marker, aruco_dict,
-                                                                                   parameters=aruco_params)
-
-        self.assertEqual(1, len(expected_ids))
-        self.assertEqual(id, expected_ids[0])
-        for i in range(0, len(expected_corners)):
-            np.testing.assert_array_equal(gold_corners, expected_corners[i].reshape(4, 2))
-
-    def test_drawCharucoDiamond(self):
-        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
-        img = cv.aruco.drawCharucoDiamond(aruco_dict, np.array([0, 1, 2, 3]), 100, 80)
-        self.assertTrue(img is not None)
-
-if __name__ == '__main__':
-    NewOpenCVTests.bootstrap()

modules/aruco/src/aruco.cpp

@@ -1,143 +0,0 @@
-// 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 "precomp.hpp"
-#include "opencv2/aruco.hpp"
-#include <opencv2/calib3d.hpp>
-#include <opencv2/core/utils/logger.hpp>
-
-namespace cv {
-namespace aruco {
-
-using namespace std;
-
-void detectMarkers(InputArray _image, const Ptr<Dictionary> &_dictionary, OutputArrayOfArrays _corners,
-                   OutputArray _ids, const Ptr<DetectorParameters> &_params,
-                   OutputArrayOfArrays _rejectedImgPoints) {
-    ArucoDetector detector(*_dictionary, *_params);
-    detector.detectMarkers(_image, _corners, _ids, _rejectedImgPoints);
-}
-
-void refineDetectedMarkers(InputArray _image, const Ptr<Board> &_board,
-                           InputOutputArrayOfArrays _detectedCorners, InputOutputArray _detectedIds,
-                           InputOutputArrayOfArrays _rejectedCorners, InputArray _cameraMatrix,
-                           InputArray _distCoeffs, float minRepDistance, float errorCorrectionRate,
-                           bool checkAllOrders, OutputArray _recoveredIdxs,
-                           const Ptr<DetectorParameters> &_params) {
-    RefineParameters refineParams(minRepDistance, errorCorrectionRate, checkAllOrders);
-    ArucoDetector detector(_board->getDictionary(), *_params, refineParams);
-    detector.refineDetectedMarkers(_image, *_board, _detectedCorners, _detectedIds, _rejectedCorners, _cameraMatrix,
-                                   _distCoeffs, _recoveredIdxs);
-}
-
-void drawPlanarBoard(const Ptr<Board> &board, Size outSize, const _OutputArray &img, int marginSize, int borderBits) {
-    board->generateImage(outSize, img, marginSize, borderBits);
-}
-
-void getBoardObjectAndImagePoints(const Ptr<Board> &board, InputArrayOfArrays detectedCorners, InputArray detectedIds,
-                                  OutputArray objPoints, OutputArray imgPoints) {
-    board->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints);
-}
-
-int estimatePoseBoard(InputArrayOfArrays corners, InputArray ids, const Ptr<Board> &board,
-                      InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec,
-                      InputOutputArray tvec, bool useExtrinsicGuess) {
-    CV_Assert(corners.total() == ids.total());
-
-    // get object and image points for the solvePnP function
-    Mat objPoints, imgPoints;
-    board->matchImagePoints(corners, ids, objPoints, imgPoints);
-
-    CV_Assert(imgPoints.total() == objPoints.total());
-
-    if(objPoints.total() == 0) // 0 of the detected markers in board
-        return 0;
-
-    solvePnP(objPoints, imgPoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess);
-
-    // divide by four since all the four corners are concatenated in the array for each marker
-    return (int)objPoints.total() / 4;
-}
-
-bool estimatePoseCharucoBoard(InputArray charucoCorners, InputArray charucoIds,
-                              const Ptr<CharucoBoard> &board, InputArray cameraMatrix,
-                              InputArray distCoeffs, InputOutputArray rvec,
-                              InputOutputArray tvec, bool useExtrinsicGuess) {
-    CV_Assert((charucoCorners.getMat().total() == charucoIds.getMat().total()));
-    if(charucoIds.getMat().total() < 4) return false;
-
-    // get object and image points for the solvePnP function
-    Mat objPoints, imgPoints;
-    board->matchImagePoints(charucoCorners, charucoIds, objPoints, imgPoints);
-    try {
-        solvePnP(objPoints, imgPoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess);
-    }
-    catch (const cv::Exception& e) {
-        CV_LOG_WARNING(NULL, "estimatePoseCharucoBoard: " << std::endl << e.what());
-        return false;
-    }
-
-    return objPoints.total() > 0ull;
-}
-
-bool testCharucoCornersCollinear(const Ptr<CharucoBoard> &board, InputArray charucoIds) {
-    return board->checkCharucoCornersCollinear(charucoIds);
-}
-
-/**
-  * @brief Return object points for the system centered in a middle (by default) or in a top left corner of single
-  * marker, given the marker length
-  */
-static Mat _getSingleMarkerObjectPoints(float markerLength, const EstimateParameters& estimateParameters) {
-    CV_Assert(markerLength > 0);
-    Mat objPoints(4, 1, CV_32FC3);
-    // set coordinate system in the top-left corner of the marker, with Z pointing out
-    if (estimateParameters.pattern == ARUCO_CW_TOP_LEFT_CORNER) {
-        objPoints.ptr<Vec3f>(0)[0] = Vec3f(0.f, 0.f, 0);
-        objPoints.ptr<Vec3f>(0)[1] = Vec3f(markerLength, 0.f, 0);
-        objPoints.ptr<Vec3f>(0)[2] = Vec3f(markerLength, markerLength, 0);
-        objPoints.ptr<Vec3f>(0)[3] = Vec3f(0.f, markerLength, 0);
-    }
-    else if (estimateParameters.pattern == ARUCO_CCW_CENTER) {
-        objPoints.ptr<Vec3f>(0)[0] = Vec3f(-markerLength/2.f, markerLength/2.f, 0);
-        objPoints.ptr<Vec3f>(0)[1] = Vec3f(markerLength/2.f, markerLength/2.f, 0);
-        objPoints.ptr<Vec3f>(0)[2] = Vec3f(markerLength/2.f, -markerLength/2.f, 0);
-        objPoints.ptr<Vec3f>(0)[3] = Vec3f(-markerLength/2.f, -markerLength/2.f, 0);
-    }
-    else
-        CV_Error(Error::StsBadArg, "Unknown estimateParameters pattern");
-    return objPoints;
-}
-
-void estimatePoseSingleMarkers(InputArrayOfArrays _corners, float markerLength,
-                               InputArray _cameraMatrix, InputArray _distCoeffs,
-                               OutputArray _rvecs, OutputArray _tvecs, OutputArray _objPoints,
-                               const Ptr<EstimateParameters>& estimateParameters) {
-    CV_Assert(markerLength > 0);
-
-    Mat markerObjPoints = _getSingleMarkerObjectPoints(markerLength, *estimateParameters);
-    int nMarkers = (int)_corners.total();
-    _rvecs.create(nMarkers, 1, CV_64FC3);
-    _tvecs.create(nMarkers, 1, CV_64FC3);
-
-    Mat rvecs = _rvecs.getMat(), tvecs = _tvecs.getMat();
-
-    //// for each marker, calculate its pose
-    parallel_for_(Range(0, nMarkers), [&](const Range& range) {
-        const int begin = range.start;
-        const int end = range.end;
-
-        for (int i = begin; i < end; i++) {
-            solvePnP(markerObjPoints, _corners.getMat(i), _cameraMatrix, _distCoeffs, rvecs.at<Vec3d>(i),
-                     tvecs.at<Vec3d>(i), estimateParameters->useExtrinsicGuess, estimateParameters->solvePnPMethod);
-        }
-    });
-
-    if(_objPoints.needed()){
-        markerObjPoints.convertTo(_objPoints, -1);
-    }
-}
-
-}
-}

modules/aruco/src/aruco_calib.cpp

@@ -1,98 +0,0 @@
-// 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 <opencv2/aruco/aruco_calib.hpp>
-#include <opencv2/calib3d.hpp>
-
-namespace cv {
-namespace aruco {
-using namespace std;
-
-EstimateParameters::EstimateParameters() : pattern(ARUCO_CCW_CENTER), useExtrinsicGuess(false),
-                                           solvePnPMethod(SOLVEPNP_ITERATIVE) {}
-
-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, const TermCriteria& criteria) {
-    // for each frame, get properly processed imagePoints and objectPoints for the calibrateCamera
-    // function
-    vector<Mat> processedObjectPoints, processedImagePoints;
-    size_t nFrames = _counter.total();
-    int markerCounter = 0;
-    for(size_t frame = 0; frame < nFrames; frame++) {
-        int nMarkersInThisFrame =  _counter.getMat().ptr< int >()[frame];
-        vector<Mat> thisFrameCorners;
-        vector<int> thisFrameIds;
-
-        CV_Assert(nMarkersInThisFrame > 0);
-
-        thisFrameCorners.reserve((size_t) nMarkersInThisFrame);
-        thisFrameIds.reserve((size_t) nMarkersInThisFrame);
-        for(int j = markerCounter; j < markerCounter + nMarkersInThisFrame; j++) {
-            thisFrameCorners.push_back(_corners.getMat(j));
-            thisFrameIds.push_back(_ids.getMat().ptr< int >()[j]);
-        }
-        markerCounter += nMarkersInThisFrame;
-        Mat currentImgPoints, currentObjPoints;
-        board->matchImagePoints(thisFrameCorners, thisFrameIds, currentObjPoints,
-            currentImgPoints);
-        if(currentImgPoints.total() > 0 && currentObjPoints.total() > 0) {
-            processedImagePoints.push_back(currentImgPoints);
-            processedObjectPoints.push_back(currentObjPoints);
-        }
-    }
-    return calibrateCamera(processedObjectPoints, processedImagePoints, imageSize, _cameraMatrix, _distCoeffs, _rvecs,
-                           _tvecs, _stdDeviationsIntrinsics, _stdDeviationsExtrinsics, _perViewErrors, flags, criteria);
-}
-
-double calibrateCameraAruco(InputArrayOfArrays _corners, InputArray _ids, InputArray _counter, const Ptr<Board> &board,
-                            Size imageSize, InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs,
-                            OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags, const TermCriteria& criteria) {
-    return calibrateCameraAruco(_corners, _ids, _counter, board, imageSize, _cameraMatrix, _distCoeffs,
-                                _rvecs, _tvecs, noArray(), noArray(), noArray(), flags, criteria);
-}
-
-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, const 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->getChessboardCorners().size());
-            allObjPoints[i].push_back(_board->getChessboardCorners()[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, const TermCriteria& criteria) {
-return calibrateCameraCharuco(_charucoCorners, _charucoIds, _board, imageSize, _cameraMatrix, _distCoeffs, _rvecs,
-                              _tvecs, noArray(), noArray(), noArray(), flags, criteria);
-}
-
-}
-}

modules/aruco/src/charuco.cpp

@@ -1,62 +0,0 @@
-// 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 "precomp.hpp"
-#include <opencv2/calib3d.hpp>
-#include "opencv2/aruco/charuco.hpp"
-#include <opencv2/imgproc.hpp>
-
-namespace cv {
-namespace aruco {
-
-using namespace std;
-
-int interpolateCornersCharuco(InputArrayOfArrays _markerCorners, InputArray _markerIds,
-                              InputArray _image, const Ptr<CharucoBoard> &_board,
-                              OutputArray _charucoCorners, OutputArray _charucoIds,
-                              InputArray _cameraMatrix, InputArray _distCoeffs, int minMarkers) {
-    CharucoParameters params;
-    params.minMarkers = minMarkers;
-    params.cameraMatrix = _cameraMatrix.getMat();
-    params.distCoeffs = _distCoeffs.getMat();
-    CharucoDetector detector(*_board, params);
-    vector<Mat> markerCorners;
-    _markerCorners.getMatVector(markerCorners);
-    detector.detectBoard(_image, _charucoCorners, _charucoIds, markerCorners, _markerIds.getMat());
-    return (int)_charucoIds.total();
-}
-
-
-void detectCharucoDiamond(InputArray _image, InputArrayOfArrays _markerCorners, InputArray _markerIds,
-                          float squareMarkerLengthRate, OutputArrayOfArrays _diamondCorners, OutputArray _diamondIds,
-                          InputArray _cameraMatrix, InputArray _distCoeffs, Ptr<Dictionary> dictionary) {
-    CharucoParameters params;
-    params.cameraMatrix = _cameraMatrix.getMat();
-    params.distCoeffs = _distCoeffs.getMat();
-    CharucoBoard board({3, 3}, squareMarkerLengthRate, 1.f, *dictionary);
-    CharucoDetector detector(board, params);
-    vector<Mat> markerCorners;
-    _markerCorners.getMatVector(markerCorners);
-
-    detector.detectDiamonds(_image, _diamondCorners, _diamondIds, markerCorners, _markerIds.getMat());
-}
-
-
-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);
-
-    // assign the charuco marker ids
-    vector<int> tmpIds(4);
-    for(int i = 0; i < 4; i++)
-       tmpIds[i] = ids[i];
-    // create a charuco board similar to a charuco marker and print it
-    CharucoBoard board(Size(3, 3), (float)squareLength, (float)markerLength, *dictionary, tmpIds);
-    Size outSize(3 * squareLength + 2 * marginSize, 3 * squareLength + 2 * marginSize);
-    board.generateImage(outSize, _img, marginSize, borderBits);
-}
-
-}
-}

modules/aruco/src/precomp.hpp

@@ -1,11 +0,0 @@
-// 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_CCALIB_PRECOMP__
-#define __OPENCV_CCALIB_PRECOMP__
-
-#include <opencv2/core.hpp>
-#include <vector>
-
-#endif

modules/bgsegm/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "Background Segmentation Algorithms")
-ocv_define_module(bgsegm opencv_core opencv_imgproc opencv_video opencv_calib3d WRAP python java objc)
+ocv_define_module(bgsegm opencv_core opencv_imgproc opencv_video opencv_3d WRAP python java objc)

modules/bgsegm/src/bgfg_gsoc.cpp

@@ -50,7 +50,7 @@
 */
 
 #include "precomp.hpp"
-#include <opencv2/calib3d.hpp>
+#include <opencv2/3d.hpp>
 #include <iostream>
 #include "opencv2/core/cvdef.h"
 

modules/bioinspired/src/retina_ocl.cpp

@@ -390,7 +390,7 @@ bool RetinaOCLImpl::convertToColorPlanes(const UMat& input, UMat &output)
     }
     else
     {
-        CV_Error(-1, "Retina ocl only support 1, 3, 4 channel input");
+        CV_Error(cv::Error::StsError, "Retina ocl only support 1, 3, 4 channel input");
     }
 }
 void RetinaOCLImpl::convertToInterleaved(const UMat& input, bool colorMode, UMat &output)

modules/bioinspired/src/retinafasttonemapping.cpp

@@ -107,7 +107,7 @@ public:
 
         // basic error check
         if (nbPixels <= 0)
-        throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "RetinaImpl::setup", "retinafasttonemapping.cpp", 0);
+            CV_Error(cv::Error::StsError, "Bad retina size setup : size height and with must be superior to zero");
 
         // resize buffers
         _inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...)
@@ -222,7 +222,7 @@ bool _convertCvMat2ValarrayBuffer(InputArray inputMat, std::valarray<float> &out
     const Mat inputMatToConvert=inputMat.getMat();
     // first check input consistency
     if (inputMatToConvert.empty())
-        throw cv::Exception(-1, "RetinaImpl cannot be applied, input buffer is empty", "RetinaImpl::run", "RetinaImpl.h", 0);
+        CV_Error(cv::Error::StsError, "RetinaImpl cannot be applied, input buffer is empty");
 
     // retreive color mode from image input
     int imageNumberOfChannels = inputMatToConvert.channels();

modules/bioinspired/src/transientareassegmentationmodule.cpp

@@ -413,17 +413,17 @@ void TransientAreasSegmentationModuleImpl::run(InputArray inputToProcess, const
     // preliminary basic error check
     if ( (inputToSegment.rows*inputToSegment.cols) != (int)_inputToSegment.size())
     {
-    	std::stringstream errorMsg;
-    	errorMsg<<"Input matrix size does not match instance buffers setup !"
-    			<<"\n\t Input size is : "<<inputToSegment.rows*inputToSegment.cols
-    			<<"\n\t v.s. internalBuffer size is : "<<  _inputToSegment.size();
-    	throw cv::Exception(-1, errorMsg.str().c_str(), "SegmentationModule::run", "SegmentationModule.cpp", 0);
+        std::stringstream errorMsg;
+        errorMsg<<"Input matrix size does not match instance buffers setup !"
+                <<"\n\t Input size is : "<<inputToSegment.rows*inputToSegment.cols
+                <<"\n\t v.s. internalBuffer size is : "<<  _inputToSegment.size();
+        CV_Error(cv::Error::StsError, errorMsg.str().c_str());
     }
     if (channelIndex >= inputToSegment.channels())
     {
-    	std::stringstream errorMsg;
-    	errorMsg<<"Cannot access channel index "<<channelIndex<<" on the input matrix with channels quantity = "<<inputToSegment.channels();
-    	throw cv::Exception(-1, errorMsg.str().c_str(), "SegmentationModule::run", "SegmentationModule.cpp", 0);
+        std::stringstream errorMsg;
+        errorMsg<<"Cannot access channel index "<<channelIndex<<" on the input matrix with channels quantity = "<<inputToSegment.channels();
+        CV_Error(cv::Error::StsError, errorMsg.str().c_str());
     }
 
     // create a cv::Mat header for the input valarray
@@ -538,7 +538,7 @@ bool TransientAreasSegmentationModuleImpl::_convertCvMat2ValarrayBuffer(InputArr
     const Mat inputMatToConvert=inputMat.getMat();
     // first check input consistency
     if (inputMatToConvert.empty())
-        throw cv::Exception(-1, "RetinaImpl cannot be applied, input buffer is empty", "RetinaImpl::run", "RetinaImpl.h", 0);
+        CV_Error(cv::Error::StsError, "RetinaImpl cannot be applied, input buffer is empty");
 
     // retreive color mode from image input
     int imageNumberOfChannels = inputMatToConvert.channels();

modules/ccalib/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "Custom Calibration Pattern")
-ocv_define_module(ccalib opencv_core opencv_imgproc opencv_calib3d opencv_features2d opencv_highgui opencv_imgcodecs WRAP python)
+ocv_define_module(ccalib opencv_core opencv_imgproc opencv_3d opencv_calib opencv_features opencv_xfeatures2d opencv_highgui opencv_imgcodecs WRAP python)

modules/ccalib/include/opencv2/ccalib.hpp

@@ -43,9 +43,9 @@
 #define __OPENCV_CCALIB_HPP__
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 #include <opencv2/imgproc.hpp>
-#include <opencv2/calib3d.hpp>
+#include <opencv2/3d.hpp>
 
 #include <vector>
 

modules/ccalib/include/opencv2/ccalib/multicalib.hpp

@@ -132,8 +132,8 @@ public:
     MultiCameraCalibration(int cameraType, int nCameras, const std::string& fileName, float patternWidth,
         float patternHeight, int verbose = 0, int showExtration = 0, int nMiniMatches = 20, int flags = 0,
         TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 200, 1e-7),
-        Ptr<FeatureDetector> detector = AKAZE::create(AKAZE::DESCRIPTOR_MLDB, 0, 3, 0.006f),
-        Ptr<DescriptorExtractor> descriptor = AKAZE::create(AKAZE::DESCRIPTOR_MLDB,0, 3, 0.006f),
+        Ptr<FeatureDetector> detector = xfeatures2d::AKAZE::create(xfeatures2d::AKAZE::DESCRIPTOR_MLDB, 0, 3, 0.006f),
+        Ptr<DescriptorExtractor> descriptor = xfeatures2d::AKAZE::create(xfeatures2d::AKAZE::DESCRIPTOR_MLDB,0, 3, 0.006f),
         Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-L1"));
 
     /* @brief load images

modules/ccalib/include/opencv2/ccalib/randpattern.hpp

@@ -42,7 +42,8 @@
 #ifndef __OPENCV_RANDOMPATTERN_HPP__
 #define __OPENCV_RANDOMPATTERN_HPP__
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
+#include "opencv2/xfeatures2d.hpp"
 #include "opencv2/highgui.hpp"
 
 namespace cv { namespace randpattern {
@@ -79,8 +80,8 @@ public:
     */
     RandomPatternCornerFinder(float patternWidth, float patternHeight,
         int nminiMatch = 20, int depth = CV_32F, int verbose = 0, int showExtraction = 0,
-        Ptr<FeatureDetector> detector = AKAZE::create(AKAZE::DESCRIPTOR_MLDB, 0, 3, 0.005f),
-        Ptr<DescriptorExtractor> descriptor = AKAZE::create(AKAZE::DESCRIPTOR_MLDB,0, 3, 0.005f),
+        Ptr<FeatureDetector> detector = xfeatures2d::AKAZE::create(xfeatures2d::AKAZE::DESCRIPTOR_MLDB, 0, 3, 0.005f),
+        Ptr<DescriptorExtractor> descriptor = xfeatures2d::AKAZE::create(xfeatures2d::AKAZE::DESCRIPTOR_MLDB,0, 3, 0.005f),
         Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-L1"));
 
     /* @brief Load pattern image and compute features for pattern

modules/ccalib/samples/omni_calibration.cpp

@@ -1,7 +1,8 @@
 #include "opencv2/ccalib/omnidir.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/calib.hpp"
 #include "opencv2/highgui.hpp"
 #include <vector>
 #include <iostream>

modules/ccalib/samples/omni_stereo_calibration.cpp

@@ -2,7 +2,8 @@
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/calib.hpp"
 #include <vector>
 #include <iostream>
 #include <string>

modules/ccalib/samples/random_pattern_calibration.cpp

@@ -1,7 +1,8 @@
 #include "opencv2/ccalib/randpattern.hpp"
 #include "opencv2/highgui.hpp"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/calib.hpp"
 #include <vector>
 #include <iostream>
 #include <time.h>

modules/ccalib/src/ccalib.cpp

@@ -47,10 +47,10 @@
 #include "opencv2/ccalib.hpp"
 
 #include <opencv2/core.hpp>
-#include <opencv2/core/types_c.h> // CV_TERM
 #include <opencv2/imgproc.hpp>
-#include <opencv2/calib3d.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/3d.hpp>
+#include <opencv2/calib.hpp>
+#include <opencv2/features.hpp>
 
 #include <vector>
 #include <cstring>
@@ -221,7 +221,7 @@ void CustomPattern::refinePointsPos(const Mat& img, vector<Point2f>& p)
     Mat gray;
     cvtColor(img, gray, COLOR_RGB2GRAY);
     cornerSubPix(gray, p, Size(10, 10), Size(-1, -1),
-                TermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 30, 0.1));
+                TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 30, 0.1));
 
 }
 

modules/ccalib/src/multicalib.cpp

@@ -225,7 +225,7 @@ void MultiCameraCalibration::loadImages()
         _xi[camera].convertTo(_xi[camera], CV_32F);
         //else
         //{
-        //    CV_Error_(CV_StsOutOfRange, "Unknown camera type, use PINHOLE or OMNIDIRECTIONAL");
+        //    CV_Error_(cv::Error::StsOutOfRange, "Unknown camera type, use PINHOLE or OMNIDIRECTIONAL");
         //}
 
         for (int i = 0; i < (int)_omEachCamera[camera].size(); ++i)

modules/ccalib/src/omnidir.cpp

@@ -58,6 +58,7 @@
  */
 #include "precomp.hpp"
 #include "opencv2/ccalib/omnidir.hpp"
+#include "opencv2/stereo.hpp"
 #include <fstream>
 #include <iostream>
 namespace cv { namespace

modules/ccalib/src/precomp.hpp

@@ -44,8 +44,10 @@
 #define __OPENCV_PRECOMP_H__
 
 #include <opencv2/core.hpp>
-#include <opencv2/calib3d.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/3d.hpp>
+#include <opencv2/calib.hpp>
+#include <opencv2/features.hpp>
+#include "opencv2/xfeatures2d.hpp"
 #include "opencv2/imgcodecs.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"

modules/ccalib/tutorials/omnidir_tutorial.markdown

@@ -17,7 +17,7 @@ This tutorial will introduce the following parts of omnidirectional camera calib
 -    calibrate a stereo pair of cameras.
 -    rectify images so that large distoration is removed.
 -    reconstruct 3D from two stereo images, with large filed of view.
--    comparison with fisheye model in opencv/calib3d/
+-    comparison with fisheye model in opencv/calib/
 
 Single Camera Calibration
 ---------------------

modules/cnn_3dobj/CMakeLists.txt

@@ -39,7 +39,7 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 include_directories(${Caffe_INCLUDE_DIR})
 set(the_description "CNN for 3D object recognition and pose estimation including a completed Sphere View on 3D objects")
-ocv_define_module(cnn_3dobj opencv_core opencv_imgproc ${Caffe_LIBS} ${Glog_LIBS} ${Protobuf_LIBS} OPTIONAL opencv_features2d opencv_viz opencv_calib3d WRAP python)
+ocv_define_module(cnn_3dobj opencv_core opencv_imgproc ${Caffe_LIBS} ${Glog_LIBS} ${Protobuf_LIBS} OPTIONAL opencv_features opencv_viz opencv_3d WRAP python)
 ocv_add_testdata(testdata/cv contrib/cnn_3dobj)
 
 if(TARGET opencv_test_cnn_3dobj)

modules/cnn_3dobj/samples/classify.cpp

@@ -38,7 +38,7 @@
  * @author Yida Wang
  */
 #include <opencv2/cnn_3dobj.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 #include <iomanip>
 using namespace cv;
 using namespace std;

modules/cnn_3dobj/samples/video.cpp

@@ -1,9 +1,9 @@
 #include <opencv2/viz/vizcore.hpp>
-#include <opencv2/calib3d.hpp>
+#include <opencv2/3d.hpp>
 #include <iostream>
 #include <fstream>
 #include <opencv2/cnn_3dobj.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 #include <iomanip>
 using namespace cv;
 using namespace std;

modules/cudacodec/src/ffmpeg_video_source.cpp

@@ -54,16 +54,12 @@ using namespace cv::cudacodec::detail;
 
 static std::string fourccToString(int fourcc)
 {
-    union {
-        int u32;
-        unsigned char c[4];
-    } i32_c;
-    i32_c.u32 = fourcc;
-    return cv::format("%c%c%c%c",
-        (i32_c.c[0] >= ' ' && i32_c.c[0] < 128) ? i32_c.c[0] : '?',
-        (i32_c.c[1] >= ' ' && i32_c.c[1] < 128) ? i32_c.c[1] : '?',
-        (i32_c.c[2] >= ' ' && i32_c.c[2] < 128) ? i32_c.c[2] : '?',
-        (i32_c.c[3] >= ' ' && i32_c.c[3] < 128) ? i32_c.c[3] : '?');
+    char str[5] = {'\0', '\0', '\0', '\0'};
+    for (int i = 0; i < 4; i++) {
+        char c = (char)(fourcc >> i*8);
+        str[i] = ' ' <= c && c < 128 ? c : '?';
+    }
+    return std::string(str);
 }
 
 static

modules/cudafeatures2d/CMakeLists.txt

@@ -8,4 +8,4 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4100 /wd4324 /wd4512 /wd4515 -Wu
 if(ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
   ocv_module_include_directories(${CUDAToolkit_INCLUDE_DIRS})
 endif()
-ocv_define_module(cudafeatures2d opencv_features2d opencv_cudafilters opencv_cudawarping WRAP python)
+ocv_define_module(cudafeatures2d opencv_features opencv_cudafilters opencv_cudawarping WRAP python)

modules/cudafeatures2d/include/opencv2/cudafeatures2d.hpp

@@ -48,7 +48,7 @@
 #endif
 
 #include "opencv2/core/cuda.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 #include "opencv2/cudafilters.hpp"
 
 /**

modules/cudafeatures2d/perf/perf_precomp.hpp

@@ -46,7 +46,7 @@
 #include "opencv2/ts/cuda_perf.hpp"
 
 #include "opencv2/cudafeatures2d.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 namespace opencv_test {
 using namespace perf;

modules/cudafeatures2d/src/precomp.hpp

@@ -50,7 +50,7 @@
 #include "opencv2/cudafeatures2d.hpp"
 #include "opencv2/cudaarithm.hpp"
 #include "opencv2/cudawarping.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "opencv2/core/private.cuda.hpp"
 

modules/cudafeatures2d/test/test_precomp.hpp

@@ -46,7 +46,7 @@
 #include "opencv2/ts/cuda_test.hpp"
 
 #include "opencv2/cudafeatures2d.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "cvconfig.h"
 

modules/cudaimgproc/test/test_histogram.cpp

@@ -107,7 +107,6 @@ CUDA_TEST_P(HistEven, Accuracy)
     Mat srcRoi = src(roi);
     cv::calcHist(&srcRoi, 1, channels, cv::Mat(), hist_gold, 1, histSize, ranges);
 
-    hist_gold = hist_gold.t();
     hist_gold.convertTo(hist_gold, CV_32S);
 
     EXPECT_MAT_NEAR(hist_gold, hist, 0.0);

modules/cudalegacy/CMakeLists.txt

@@ -9,4 +9,4 @@ if(ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
   ocv_module_include_directories(${CUDAToolkit_INCLUDE_DIRS})
 endif()
 ocv_define_module(cudalegacy opencv_core opencv_video
-  OPTIONAL opencv_objdetect opencv_imgproc opencv_calib3d opencv_cudaarithm opencv_cudafilters opencv_cudaimgproc)
+  OPTIONAL opencv_objdetect opencv_xobjdetect opencv_imgproc opencv_3d opencv_stereo opencv_calib opencv_cudaarithm opencv_cudafilters opencv_cudaimgproc)

modules/cudalegacy/perf/perf_calib3d.cpp

@@ -42,9 +42,9 @@
 
 #include "perf_precomp.hpp"
 
-#ifdef HAVE_OPENCV_CALIB3D
+#ifdef HAVE_OPENCV_3D
 
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
 
 namespace opencv_test { namespace {
 

modules/cudalegacy/src/NCV.cpp

@@ -739,12 +739,12 @@ struct RectConvert
 
 static void groupRectangles(std::vector<NcvRect32u> &hypotheses, int groupThreshold, double eps, std::vector<Ncv32u> *weights)
 {
-#ifndef HAVE_OPENCV_OBJDETECT
+#ifndef HAVE_OPENCV_XOBJDETECT
     CV_UNUSED(hypotheses);
     CV_UNUSED(groupThreshold);
     CV_UNUSED(eps);
     CV_UNUSED(weights);
-    CV_Error(cv::Error::StsNotImplemented, "This functionality requires objdetect module");
+    CV_Error(cv::Error::StsNotImplemented, "This functionality requires xobjdetect module");
 #else
     std::vector<cv::Rect> rects(hypotheses.size());
     std::transform(hypotheses.begin(), hypotheses.end(), rects.begin(), RectConvert());

modules/cudalegacy/src/calib3d.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined HAVE_CUDA || !defined HAVE_OPENCV_CALIB3D || defined(CUDA_DISABLER)
+#if !defined HAVE_CUDA || !defined HAVE_OPENCV_3D || defined(CUDA_DISABLER)
 
 void cv::cuda::transformPoints(const GpuMat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_no_cuda(); }
 

modules/cudalegacy/src/cuda/NCVHaarObjectDetection.cu

@@ -64,9 +64,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_OBJDETECT
-#  include "opencv2/objdetect.hpp"
-//#  include "opencv2/objdetect/objdetect_c.h"
+#ifdef HAVE_OPENCV_XOBJDETECT
+#  include "opencv2/xobjdetect.hpp"
 #endif
 
 #include "opencv2/cudalegacy/NCV.hpp"
@@ -1843,16 +1842,16 @@ static NCVStatus loadFromXML(const cv::String &filename,
                       std::vector<HaarClassifierNode128> &haarClassifierNodes,
                       std::vector<HaarFeature64> &haarFeatures)
 {
-    const char *CUDA_CC_SIZE = "size";
-    const char *CUDA_CC_STAGES = "stages";
-    const char *CUDA_CC_STAGE_THRESHOLD = "stage_threshold";
-    const char *CUDA_CC_TREES = "trees";
-    const char *CUDA_CC_FEATURE = "feature";
-    const char *CUDA_CC_RECT = "rects";
-    const char *CUDA_CC_TILTED = "tilted";
-    const char *CUDA_CC_THRESHOLD = "threshold";
+    const char *CUDA_CC_SIZE = "size";
+    const char *CUDA_CC_STAGES = "stages";
+    const char *CUDA_CC_STAGE_THRESHOLD = "stage_threshold";
+    const char *CUDA_CC_TREES = "trees";
+    const char *CUDA_CC_FEATURE = "feature";
+    const char *CUDA_CC_RECT = "rects";
+    const char *CUDA_CC_TILTED = "tilted";
+    const char *CUDA_CC_THRESHOLD = "threshold";
     const char *CUDA_CC_LEFT_VAL = "left_val";
-    const char *CUDA_CC_RIGHT_VAL = "right_val";
+    const char *CUDA_CC_RIGHT_VAL = "right_val";
     const char *CUDA_CC_LEFT_NODE = "left_node";
     const char *CUDA_CC_RIGHT_NODE = "right_node";
 
@@ -1873,12 +1872,12 @@ static NCVStatus loadFromXML(const cv::String &filename,
     haarClassifierNodes.resize(0);
     haarFeatures.resize(0);
 
-    cv::FileStorage fs(filename, cv::FileStorage::READ | cv::FileStorage::FORMAT_XML);
-
-    if (!fs.isOpened())
+    cv::FileStorage fs(filename, cv::FileStorage::READ | cv::FileStorage::FORMAT_XML);
+
+    if (!fs.isOpened())
         return NCV_FILE_ERROR;
 
-    const cv::FileNode &root = fs.getFirstTopLevelNode();
+    const cv::FileNode &root = fs.getFirstTopLevelNode();
     const cv::FileNode &fnSize = root[CUDA_CC_SIZE];
 
     // collect the cascade classifier window size
@@ -1886,47 +1885,47 @@ static NCVStatus loadFromXML(const cv::String &filename,
     haar.ClassifierSize.height = (int)fnSize[CUDA_CC_SIZE_H];
     CV_Assert(haar.ClassifierSize.height > 0 && haar.ClassifierSize.width > 0);
 
-    const cv::FileNode &fnStages = root[CUDA_CC_STAGES];
+    const cv::FileNode &fnStages = root[CUDA_CC_STAGES];
     cv::FileNodeIterator it = fnStages.begin(), it_end = fnStages.end();
 
-    for (; it != it_end; ++it) // by stages
-    {
-        cv::FileNode fnStage = *it;
+    for (; it != it_end; ++it) // by stages
+    {
+        cv::FileNode fnStage = *it;
         HaarStage64 curStage;
 
-        curStage.setStartClassifierRootNodeOffset(static_cast<Ncv32u>(haarClassifierNodes.size()));
+        curStage.setStartClassifierRootNodeOffset(static_cast<Ncv32u>(haarClassifierNodes.size()));
         curStage.setStageThreshold((float)fnStage[CUDA_CC_STAGE_THRESHOLD]);
 
-        // iterate over the trees
-        const cv::FileNode &fnTrees = fnStage[CUDA_CC_TREES];
-        cv::FileNodeIterator it1 = fnTrees.begin(), it1_end = fnTrees.end();
-
-        for (; it1 != it1_end; ++it1) // by trees
-        {
-            cv::FileNode tree = *it1;
-            Ncv32u nodeId = (size_t)0;
-            HaarClassifierNode128 curNode;
-
-            curNode.setThreshold((float)tree[0][CUDA_CC_THRESHOLD]);
-
-            NcvBool bIsLeftNodeLeaf = false;
-            NcvBool bIsRightNodeLeaf = false;
-
+        // iterate over the trees
+        const cv::FileNode &fnTrees = fnStage[CUDA_CC_TREES];
+        cv::FileNodeIterator it1 = fnTrees.begin(), it1_end = fnTrees.end();
+
+        for (; it1 != it1_end; ++it1) // by trees
+        {
+            cv::FileNode tree = *it1;
+            Ncv32u nodeId = (size_t)0;
+            HaarClassifierNode128 curNode;
+
+            curNode.setThreshold((float)tree[0][CUDA_CC_THRESHOLD]);
+
+            NcvBool bIsLeftNodeLeaf = false;
+            NcvBool bIsRightNodeLeaf = false;
+
             HaarClassifierNodeDescriptor32 nodeLeft;
 
             cv::FileNode leftNode = tree[0][CUDA_CC_LEFT_NODE];
 
             if (leftNode.fs == NULL)
             {
-                Ncv32f leftVal = tree[0][CUDA_CC_LEFT_VAL];
-                ncvStat = nodeLeft.create(leftVal);
+                Ncv32f leftVal = tree[0][CUDA_CC_LEFT_VAL];
+                ncvStat = nodeLeft.create(leftVal);
                 ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
                 bIsLeftNodeLeaf = true;
             }
             else
             {
-                Ncv32u leftNodeOffset = (int)tree[0][CUDA_CC_LEFT_NODE];
-                nodeLeft.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1));
+                Ncv32u leftNodeOffset = (int)tree[0][CUDA_CC_LEFT_NODE];
+                nodeLeft.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + leftNodeOffset - 1));
                 haar.bHasStumpsOnly = false;
             }
 
@@ -1937,15 +1936,15 @@ static NCVStatus loadFromXML(const cv::String &filename,
 
             if (rightNode.fs == NULL)
             {
-                Ncv32f rightVal = tree[0][CUDA_CC_RIGHT_VAL];
-                ncvStat = nodeRight.create(rightVal);
+                Ncv32f rightVal = tree[0][CUDA_CC_RIGHT_VAL];
+                ncvStat = nodeRight.create(rightVal);
                 ncvAssertReturn(ncvStat == NCV_SUCCESS, ncvStat);
                 bIsRightNodeLeaf = true;
             }
             else
             {
-                Ncv32u rightNodeOffset = (int)tree[0][CUDA_CC_RIGHT_NODE];
-                nodeRight.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1));
+                Ncv32u rightNodeOffset = (int)tree[0][CUDA_CC_RIGHT_NODE];
+                nodeRight.create((Ncv32u)(h_TmpClassifierNotRootNodes.size() + rightNodeOffset - 1));
                 haar.bHasStumpsOnly = false;
             }
 
@@ -1955,9 +1954,9 @@ static NCVStatus loadFromXML(const cv::String &filename,
             Ncv32u tiltedVal = (int)fnFeature[CUDA_CC_TILTED];
             haar.bNeedsTiltedII = (tiltedVal != 0);
 
-            cv::FileNodeIterator it2 = fnFeature[CUDA_CC_RECT].begin(), it2_end = fnFeature[CUDA_CC_RECT].end();
+            cv::FileNodeIterator it2 = fnFeature[CUDA_CC_RECT].begin(), it2_end = fnFeature[CUDA_CC_RECT].end();
 
-            Ncv32u featureId = 0;
+            Ncv32u featureId = 0;
             for (; it2 != it2_end; ++it2) // by feature
             {
                 cv::FileNode rect = *it2;

modules/cudalegacy/src/fgd.cpp

@@ -54,7 +54,6 @@ Ptr<cuda::BackgroundSubtractorFGD> cv::cuda::createBackgroundSubtractorFGD(const
 #else
 
 #include "cuda/fgd.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
 
 /////////////////////////////////////////////////////////////////////////
 // FGDParams
@@ -345,69 +344,29 @@ namespace
 
 namespace
 {
-    void seqToContours(CvSeq* _ccontours, CvMemStorage* storage, OutputArrayOfArrays _contours)
-    {
-        Seq<CvSeq*> all_contours(cvTreeToNodeSeq(_ccontours, sizeof(CvSeq), storage));
-
-        size_t total = all_contours.size();
-
-        _contours.create((int) total, 1, 0, -1, true);
-
-        SeqIterator<CvSeq*> it = all_contours.begin();
-        for (size_t i = 0; i < total; ++i, ++it)
-        {
-            CvSeq* c = *it;
-            ((CvContour*)c)->color = (int)i;
-            _contours.create((int)c->total, 1, CV_32SC2, (int)i, true);
-            Mat ci = _contours.getMat((int)i);
-            CV_Assert( ci.isContinuous() );
-            cvCvtSeqToArray(c, ci.data);
-        }
-    }
-
     int findForegroundRegions(GpuMat& d_foreground, Mat& h_foreground, std::vector< std::vector<Point> >& foreground_regions,
-                              CvMemStorage* storage, const FGDParams& params)
+                              const FGDParams& params)
     {
         int region_count = 0;
 
         // Discard under-size foreground regions:
-
         d_foreground.download(h_foreground);
-        IplImage ipl_foreground = cvIplImage(h_foreground);
-        CvSeq* first_seq = 0;
 
-        cvFindContours(&ipl_foreground, storage, &first_seq, sizeof(CvContour), CV_RETR_LIST);
+        std::vector<std::vector<cv::Point> > contours, result;
+        std::vector<cv::Vec4i> hierarchy;
+        cv::findContours(h_foreground, contours, hierarchy, cv::RETR_CCOMP, cv::CHAIN_APPROX_SIMPLE);
+        CV_Assert(contours.size() > 0);
 
-        for (CvSeq* seq = first_seq; seq; seq = seq->h_next)
+        // adding top-level contours to results, filtering by size
+        for (size_t i = 0; i < contours.size(); ++i)
         {
-            CvContour* cnt = reinterpret_cast<CvContour*>(seq);
-
-            if (cnt->rect.width * cnt->rect.height < params.minArea || (params.is_obj_without_holes && CV_IS_SEQ_HOLE(seq)))
-            {
-                // Delete under-size contour:
-                CvSeq* prev_seq = seq->h_prev;
-                if (prev_seq)
-                {
-                    prev_seq->h_next = seq->h_next;
-
-                    if (seq->h_next)
-                        seq->h_next->h_prev = prev_seq;
-                }
-                else
-                {
-                    first_seq = seq->h_next;
-
-                    if (seq->h_next)
-                        seq->h_next->h_prev = NULL;
-                }
-            }
-            else
-            {
-                region_count++;
-            }
+            const std::vector<cv::Point> & cnt = contours[i];
+            const cv::Rect brect = cv::boundingRect(cnt);
+            bool isHole = hierarchy[i][3] >= 0; // contour with parent is hole
+            if (brect.area() < params.minArea || (isHole && params.is_obj_without_holes))
+                continue;
+            foreground_regions.push_back(cnt);
         }
-
-        seqToContours(first_seq, storage, foreground_regions);
         h_foreground.setTo(0);
 
         drawContours(h_foreground, foreground_regions, -1, Scalar::all(255), -1);
@@ -612,19 +571,14 @@ namespace
         Ptr<cuda::Filter> dilateFilter_;
         Ptr<cuda::Filter> erodeFilter_;
 #endif
-
-        CvMemStorage* storage_;
     };
 
     FGDImpl::FGDImpl(const FGDParams& params) : params_(params), frameSize_(0, 0)
     {
-        storage_ = cvCreateMemStorage();
-        CV_Assert( storage_ != 0 );
     }
 
     FGDImpl::~FGDImpl()
     {
-        cvReleaseMemStorage(&storage_);
     }
 
     void FGDImpl::apply(InputArray _frame, OutputArray fgmask, double)
@@ -640,7 +594,6 @@ namespace
         CV_Assert( curFrame.type() == CV_8UC3 || curFrame.type() == CV_8UC4 );
         CV_Assert( curFrame.size() == prevFrame_.size() );
 
-        cvClearMemStorage(storage_);
         foreground_regions_.clear();
         foreground_.setTo(Scalar::all(0));
 
@@ -655,7 +608,7 @@ namespace
 #endif
 
         if (params_.minArea > 0 || params_.is_obj_without_holes)
-            findForegroundRegions(foreground_, h_foreground_, foreground_regions_, storage_, params_);
+            findForegroundRegions(foreground_, h_foreground_, foreground_regions_, params_);
 
         // Check ALL BG update condition:
         const double BGFG_FGD_BG_UPDATE_TRESH = 0.5;

modules/cudalegacy/src/precomp.hpp

@@ -63,8 +63,12 @@
 #  include "opencv2/objdetect.hpp"
 #endif
 
-#ifdef HAVE_OPENCV_CALIB3D
-#  include "opencv2/calib3d.hpp"
+#ifdef HAVE_OPENCV_XOBJDETECT
+#  include "opencv2/xobjdetect.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_3D
+#  include "opencv2/3d.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_CUDAARITHM

modules/cudalegacy/test/test_calib3d.cpp

@@ -42,9 +42,9 @@
 
 #include "test_precomp.hpp"
 
-#if defined HAVE_CUDA && defined HAVE_OPENCV_CALIB3D
+#if defined HAVE_CUDA && defined HAVE_OPENCV_3D
 
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
 
 namespace opencv_test { namespace {
 

modules/cudaobjdetect/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "CUDA-accelerated Object Detection")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations -Wshadow -Wstrict-aliasing)
 
-ocv_define_module(cudaobjdetect opencv_objdetect opencv_cudaarithm opencv_cudawarping OPTIONAL opencv_cudalegacy WRAP python)
+ocv_define_module(cudaobjdetect opencv_objdetect opencv_xobjdetect opencv_cudaarithm opencv_cudawarping OPTIONAL opencv_cudalegacy WRAP python)

modules/cudaobjdetect/include/opencv2/cudaobjdetect.hpp

@@ -48,7 +48,7 @@
 #endif
 
 #include "opencv2/core/cuda.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 /**
   @addtogroup cuda
@@ -70,11 +70,11 @@ namespace cv { namespace cuda {
 
 @note
     -   An example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/cpp/peopledetect.cpp
+        xobjdetect_module/samples/peopledetect.cpp
     -   A CUDA example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/gpu/hog.cpp
+        xobjdetect_module/samples/gpu/hog.cpp
     -   (Python) An example applying the HOG descriptor for people detection can be found at
-        opencv_source_code/samples/python/peopledetect.py
+        xobjdetect_module/samples/python/peopledetect.py
  */
 class CV_EXPORTS_W HOG : public Algorithm
 {
@@ -222,8 +222,8 @@ public:
 /** @brief Cascade classifier class used for object detection. Supports HAAR and LBP cascades. :
 
 @note
-   -   A cascade classifier example can be found at
-        opencv_source_code/samples/gpu/cascadeclassifier.cpp
+    -   A cascade classifier example can be found at
+        xobjdetect_module/samples/gpu/cascadeclassifier.cpp
     -   A Nvidea API specific cascade classifier example can be found at
         opencv_source_code/samples/gpu/cascadeclassifier_nvidia_api.cpp
  */

modules/cudaobjdetect/perf/perf_precomp.hpp

@@ -46,7 +46,7 @@
 #include "opencv2/ts/cuda_perf.hpp"
 
 #include "opencv2/cudaobjdetect.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 namespace opencv_test { using namespace perf; }
 

modules/cudaobjdetect/src/precomp.hpp

@@ -48,7 +48,7 @@
 #include "opencv2/cudaobjdetect.hpp"
 #include "opencv2/cudaarithm.hpp"
 #include "opencv2/cudawarping.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 #include "opencv2/core/private.cuda.hpp"
 #include "opencv2/core/utility.hpp"

modules/cudaobjdetect/test/test_precomp.hpp

@@ -48,7 +48,7 @@
 #include "opencv2/ts/cuda_test.hpp"
 
 #include "opencv2/cudaobjdetect.hpp"
-#include "opencv2/objdetect.hpp"
+#include "opencv2/xobjdetect.hpp"
 
 #include "cvconfig.h"
 

modules/cudastereo/CMakeLists.txt

@@ -8,4 +8,4 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-d
 if(ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
   ocv_module_include_directories(${CUDAToolkit_INCLUDE_DIRS})
 endif()
-ocv_define_module(cudastereo opencv_calib3d OPTIONAL opencv_cudev WRAP python)
+ocv_define_module(cudastereo opencv_3d opencv_stereo OPTIONAL opencv_cudev WRAP python)

modules/cudastereo/include/opencv2/cudastereo.hpp

@@ -48,7 +48,8 @@
 #endif
 
 #include "opencv2/core/cuda.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/stereo.hpp"
 
 /**
   @addtogroup cuda

modules/cudastereo/perf/perf_precomp.hpp

@@ -46,7 +46,8 @@
 #include "opencv2/ts/cuda_perf.hpp"
 
 #include "opencv2/cudastereo.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/stereo.hpp"
 
 namespace opencv_test {
 using namespace perf;

modules/cudastereo/test/test_precomp.hpp

@@ -46,7 +46,8 @@
 #include "opencv2/ts/cuda_test.hpp"
 
 #include "opencv2/cudastereo.hpp"
-#include "opencv2/calib3d.hpp"
+#include "opencv2/3d.hpp"
+#include "opencv2/stereo.hpp"
 
 #include "cvconfig.h"
 

modules/cudev/include/opencv2/cudev/util/vec_traits.hpp

@@ -188,6 +188,7 @@ template<> struct VecTraits<char4>
 
 namespace cv {
 
+#ifndef CV_32U
 template <> class DataType<uint>
 {
 public:
@@ -202,6 +203,7 @@ public:
            type         = CV_MAKE_TYPE(depth, channels)
          };
 };
+#endif
 
 #define CV_CUDEV_DATA_TYPE_INST(_depth_type, _channel_num) \
     template <> class DataType< _depth_type ## _channel_num > \

modules/cudev/test/test_cvt.cu

@@ -102,10 +102,10 @@ public:
 
         // Fp32 -> Fp16
         cv::cuda::convertFp16(g_src, g_dst);
-        cv::convertFp16(src, dst);
+        src.convertTo(dst, CV_16F);
         // Fp16 -> Fp32
         cv::cuda::convertFp16(g_dst.clone(), g_dst);
-        cv::convertFp16(dst, ref);
+        dst.convertTo(ref, CV_32F);
 
         g_dst.download(dst);
         EXPECT_MAT_NEAR(dst, ref, 0.0);
@@ -128,7 +128,7 @@ public:
 
         // Fp32 -> Fp16
         cv::cuda::convertFp16(g_src, g_dst);
-        cv::convertFp16(src, ref);
+        src.convertTo(ref, CV_16F);
 
         g_dst.download(dst);
         EXPECT_MAT_NEAR(dst, ref, 0.0);

modules/cudev/test/test_integral.cu

@@ -48,7 +48,7 @@ using namespace cv::cuda;
 using namespace cv::cudev;
 using namespace cvtest;
 
-TEST(Integral, _8u)
+TEST(DISABLED_Integral, _8u)
 {
     const Size size = randomSize(100, 400);
 
@@ -84,7 +84,7 @@ TEST(Integral, _32f)
     ASSERT_PRED_FORMAT2(cvtest::MatComparator(1e-5, 0), dst_gold, Mat(dst));
 }
 
-TEST(Integral, _8u_opt)
+TEST(DISABLED_Integral, _8u_opt)
 {
     const Size size(640, 480);
 

modules/cudev/test/test_nd.cu

@@ -41,12 +41,6 @@ public:
             else
                 ret.push_back(Range::all());
 
-        if (dims == 1)
-        {
-            // Mat expects two ranges even in this case
-            ret.push_back(Range::all());
-        }
-
         return ret;
     }
 

modules/cvv/CMakeLists.txt

@@ -4,7 +4,7 @@ if(NOT HAVE_QT OR NOT HAVE_CXX11 OR QT_VERSION_MAJOR LESS 5)
 endif()
 
 set(the_description "Debug visualization framework")
-ocv_add_module(cvv opencv_core opencv_imgproc opencv_features2d WRAP python)
+ocv_add_module(cvv opencv_core opencv_imgproc opencv_features WRAP python)
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshadow -Wmissing-declarations)
 
 # Qt

modules/cvv/include/opencv2/cvv/dmatch.hpp

@@ -4,7 +4,7 @@
 #include <string>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "call_meta_data.hpp"
 #include "debug_mode.hpp"

modules/cvv/samples/cvv_demo.cpp

@@ -3,10 +3,8 @@
 
 // library includes
 #include <opencv2/imgproc.hpp>
-#include <opencv2/features2d.hpp>
-#include <opencv2/imgproc/types_c.h>
+#include <opencv2/features.hpp>
 #include <opencv2/videoio.hpp>
-#include <opencv2/videoio/videoio_c.h>
 
 #define CVVISUAL_DEBUGMODE
 #include <opencv2/cvv/debug_mode.hpp>
@@ -33,8 +31,6 @@ template<class T> std::string toString(const T& p_arg)
 int
 main(int argc, char** argv)
 {
-  cv::Size* resolution = nullptr;
-
   // parser keys
   const char *keys =
       "{ help h usage ?  |   | show this message }"
@@ -58,8 +54,8 @@ main(int argc, char** argv)
 
   if (res_w>0 && res_h>0) {
     printf("Setting resolution to %dx%d\n", res_w, res_h);
-    capture.set(CV_CAP_PROP_FRAME_WIDTH, res_w);
-    capture.set(CV_CAP_PROP_FRAME_HEIGHT, res_h);
+    capture.set(cv::CAP_PROP_FRAME_WIDTH, res_w);
+    capture.set(cv::CAP_PROP_FRAME_HEIGHT, res_h);
   }
 
 

modules/cvv/src/gui/rawview_group_subtable.cpp

@@ -4,7 +4,7 @@
 #include <algorithm>
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 
 #include <QVBoxLayout>
 #include <QStringList>

modules/cvv/src/gui/rawview_table_row.hpp

@@ -5,7 +5,7 @@
 #include <utility>
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 
 #include <QTableWidget>
 #include <QString>

modules/cvv/src/impl/call.hpp

@@ -6,7 +6,7 @@
 #include <QString>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "opencv2/cvv/call_meta_data.hpp"
 

modules/cvv/src/impl/match_call.hpp

@@ -6,7 +6,7 @@
 #include <type_traits>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "call.hpp"
 

modules/cvv/src/qtutil/matchview/cvvkeypoint.hpp

@@ -10,7 +10,7 @@
 #include <QGraphicsScene>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointsettings.hpp"
 #include "../zoomableimage.hpp"

modules/cvv/src/qtutil/matchview/cvvmatch.hpp

@@ -10,7 +10,7 @@
 
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchsettings.hpp"
 #include "cvvkeypoint.hpp"

modules/cvv/src/qtutil/matchview/falsecolorkeypointpen.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointvaluechooser.hpp"
 #include "keypointsettings.hpp"

modules/cvv/src/qtutil/matchview/falsecolormatchpen.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchsettings.hpp"
 

modules/cvv/src/qtutil/matchview/keypointintervallselection.hpp

@@ -1,7 +1,7 @@
 #ifndef CVVISUAL_KEY_POINT_INTERVALL_SELECTOR
 #define CVVISUAL_KEY_POINT_INTERVALL_SELECTOR
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointselection.hpp"
 #include "keypointvaluechooser.hpp"

modules/cvv/src/qtutil/matchview/keypointmanagement.hpp

@@ -5,7 +5,7 @@
 
 #include "../../util/util.hpp"
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointselectionselector.hpp"
 #include "keypointsettingsselector.hpp"

modules/cvv/src/qtutil/matchview/keypointportionselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointselection.hpp"
 #include "keypointvaluechooser.hpp"

modules/cvv/src/qtutil/matchview/keypointselection.hpp

@@ -3,7 +3,7 @@
 
 #include <QFrame>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 namespace cvv{ namespace qtutil{
 

modules/cvv/src/qtutil/matchview/keypointselectionselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointselection.hpp"
 #include "../registerhelper.hpp"

modules/cvv/src/qtutil/matchview/keypointsettingsselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "keypointsettings.hpp"
 #include "../registerhelper.hpp"

modules/cvv/src/qtutil/matchview/keypointshowsetting.hpp

@@ -5,7 +5,7 @@
 
 #include <QPushButton>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 #include "keypointsettings.hpp"
 
 namespace cvv{ namespace qtutil{

modules/cvv/src/qtutil/matchview/keypointvaluechooser.hpp

@@ -4,7 +4,7 @@
 #include <QWidget>
 #include <QComboBox>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 
 namespace cvv{ namespace qtutil{

modules/cvv/src/qtutil/matchview/matchintervallselection.hpp

@@ -1,7 +1,7 @@
 #ifndef CVVISUAL_MATCH_INTERVALL_SELECTOR
 #define CVVISUAL_MATCH_INTERVALL_SELECTOR
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchselection.hpp"
 #include "../intervallselector.hpp"

modules/cvv/src/qtutil/matchview/matchmanagement.hpp

@@ -3,7 +3,7 @@
 
 #include <QCheckBox>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchselectionselector.hpp"
 #include "matchsettingsselector.hpp"

modules/cvv/src/qtutil/matchview/matchportionselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchselection.hpp"
 #include "../portionselector.hpp"

modules/cvv/src/qtutil/matchview/matchscene.hpp

@@ -9,7 +9,7 @@
 #include <QGraphicsProxyWidget>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 #include "cvvmatch.hpp"
 #include "cvvkeypoint.hpp"
 #include "zoomableproxyobject.hpp"

modules/cvv/src/qtutil/matchview/matchselection.hpp

@@ -3,7 +3,7 @@
 
 #include <QFrame>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 namespace cvv{ namespace qtutil{
 

modules/cvv/src/qtutil/matchview/matchselectionselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchselection.hpp"
 #include "../registerhelper.hpp"

modules/cvv/src/qtutil/matchview/matchsettingsselector.hpp

@@ -3,7 +3,7 @@
 
 #include <vector>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchsettings.hpp"
 #include "../registerhelper.hpp"

modules/cvv/src/qtutil/matchview/matchshowsetting.hpp

@@ -5,7 +5,7 @@
 
 #include <QPushButton>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 #include "matchsettings.hpp"
 #include "cvvmatch.hpp"
 

modules/cvv/src/qtutil/matchview/rawview_window.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 
 #include <QMainWindow>
 #include <QString>

modules/cvv/src/qtutil/matchview/showinrawviewwidget.hpp

@@ -3,7 +3,7 @@
 
 #include <QWidget>
 
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "matchmanagement.hpp"
 #include "keypointmanagement.hpp"

modules/cvv/src/qtutil/util.hpp

@@ -11,7 +11,7 @@
 
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 
 namespace cvv

modules/cvv/src/view/linematchview.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "../qtutil/matchview/matchmanagement.hpp"
 #include "../qtutil/matchview/keypointmanagement.hpp"

modules/cvv/src/view/match_view.hpp

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 
 #include "../impl/match_call.hpp"
 

modules/cvv/src/view/pointmatchview.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "opencv2/core.hpp"
-#include "opencv2/features2d.hpp"
+#include "opencv2/features.hpp"
 
 #include "../qtutil/matchview/matchmanagement.hpp"
 #include "match_view.hpp"

modules/cvv/src/view/rawview.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include <opencv2/core.hpp>
-#include <opencv2/features2d.hpp>
+#include <opencv2/features.hpp>
 
 #include <QWidget>
 #include <QString>