(5.x) Merge 4.x

modules/aruco/include/opencv2/aruco.hpp

@@ -169,7 +169,7 @@ struct CV_EXPORTS_W DetectorParameters {
 
     DetectorParameters();
     CV_WRAP static Ptr<DetectorParameters> create();
-    CV_WRAP static bool readDetectorParameters(const FileNode& fn, Ptr<DetectorParameters>& params);
+    CV_WRAP bool readDetectorParameters(const FileNode& fn);
 
     CV_PROP_RW int adaptiveThreshWinSizeMin;
     CV_PROP_RW int adaptiveThreshWinSizeMax;
@@ -230,21 +230,19 @@ struct CV_EXPORTS_W DetectorParameters {
  * @param parameters marker detection parameters
  * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
  * correct codification. Useful for debugging purposes.
- * @param cameraMatrix optional input 3x3 floating-point camera matrix
- * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
- * @param distCoeff optional vector of distortion coefficients
- * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
  *
  * Performs marker detection in the input image. Only markers included in the specific dictionary
  * are searched. For each detected marker, it returns the 2D position of its corner in the image
  * and its corresponding identifier.
  * Note that this function does not perform pose estimation.
- * @sa estimatePoseSingleMarkers,  estimatePoseBoard
+ * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+ * input image with corresponging camera model, if camera parameters are known
+ * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
  *
  */
 CV_EXPORTS_W void detectMarkers(InputArray image, const Ptr<Dictionary> &dictionary, OutputArrayOfArrays corners,
                                 OutputArray ids, const Ptr<DetectorParameters> &parameters = DetectorParameters::create(),
-                                OutputArrayOfArrays rejectedImgPoints = noArray(), InputArray cameraMatrix= noArray(), InputArray distCoeff= noArray());
+                                OutputArrayOfArrays rejectedImgPoints = noArray());
 
 
 
@@ -274,8 +272,9 @@ CV_EXPORTS_W void detectMarkers(InputArray image, const Ptr<Dictionary> &diction
  * The marker corrdinate system is centered on the middle of the marker, with the Z axis
  * perpendicular to the marker plane.
  * The coordinates of the four corners of the marker in its own coordinate system are:
- * (-markerLength/2, markerLength/2, 0), (markerLength/2, markerLength/2, 0),
- * (markerLength/2, -markerLength/2, 0), (-markerLength/2, -markerLength/2, 0)
+ * (0, 0, 0), (markerLength, 0, 0),
+ * (markerLength, markerLength, 0), (0, markerLength, 0)
+ * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
  */
 CV_EXPORTS_W void estimatePoseSingleMarkers(InputArrayOfArrays corners, float markerLength,
                                             InputArray cameraMatrix, InputArray distCoeffs,
@@ -318,7 +317,14 @@ class CV_EXPORTS_W Board {
     CV_WRAP void setIds(InputArray ids);
 
     /// array of object points of all the marker corners in the board
-    /// each marker include its 4 corners in CCW order. For M markers, the size is Mx4.
+    /// each marker include its 4 corners in this order:
+    ///-   objPoints[i][0] - left-top point of i-th marker
+    ///-   objPoints[i][1] - right-top point of i-th marker
+    ///-   objPoints[i][2] - right-bottom point of i-th marker
+    ///-   objPoints[i][3] - left-bottom point of i-th marker
+    ///
+    /// Markers are placed in a certain order - row by row, left to right in every row.
+    /// For M markers, the size is Mx4.
     CV_PROP std::vector< std::vector< Point3f > > objPoints;
 
     /// the dictionary of markers employed for this board
@@ -327,6 +333,9 @@ class CV_EXPORTS_W Board {
     /// vector of the identifiers of the markers in the board (same size than objPoints)
     /// The identifiers refers to the board dictionary
     CV_PROP_RW std::vector< int > ids;
+
+    /// coordinate of the bottom right corner of the board, is set when calling the function create()
+    CV_PROP Point3f rightBottomBorder;
 };
 
 
@@ -426,6 +435,7 @@ class CV_EXPORTS_W GridBoard : public Board {
  * Input markers that are not included in the board layout are ignored.
  * The function returns the number of markers from the input employed for the board pose estimation.
  * Note that returning a 0 means the pose has not been estimated.
+ * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
  */
 CV_EXPORTS_W int estimatePoseBoard(InputArrayOfArrays corners, InputArray ids, const Ptr<Board> &board,
                                    InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec,
@@ -490,36 +500,14 @@ CV_EXPORTS_W void refineDetectedMarkers(
  * Given an array of detected marker corners and its corresponding ids, this functions draws
  * the markers in the image. The marker borders are painted and the markers identifiers if provided.
  * Useful for debugging purposes.
+ *
  */
 CV_EXPORTS_W void drawDetectedMarkers(InputOutputArray image, InputArrayOfArrays corners,
                                       InputArray ids = noArray(),
                                       Scalar borderColor = Scalar(0, 255, 0));
 
 
 
-/**
- * @brief Draw coordinate system axis from pose estimation
- *
- * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
- * altered.
- * @param cameraMatrix input 3x3 floating-point camera matrix
- * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
- * @param distCoeffs vector of distortion coefficients
- * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
- * @param rvec rotation vector of the coordinate system that will be drawn. (@sa Rodrigues).
- * @param tvec translation vector of the coordinate system that will be drawn.
- * @param length length of the painted axis in the same unit than tvec (usually in meters)
- *
- * Given the pose estimation of a marker or board, this function draws the axis of the world
- * coordinate system, i.e. the system centered on the marker/board. Useful for debugging purposes.
- *
- * @deprecated use cv::drawFrameAxes
- */
-CV_EXPORTS_W void drawAxis(InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs,
-                           InputArray rvec, InputArray tvec, float length);
-
-
-
 /**
  * @brief Draw a canonical marker image
  *

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

@@ -181,6 +181,7 @@ CV_EXPORTS_W int interpolateCornersCharuco(InputArrayOfArrays markerCorners, Inp
  * This function estimates a Charuco board pose from some detected corners.
  * The function checks if the input corners are enough and valid to perform pose estimation.
  * If pose estimation is valid, returns true, else returns false.
+ * @sa use cv::drawFrameAxes to get world coordinate system axis for object points
  */
 CV_EXPORTS_W bool estimatePoseCharucoBoard(InputArray charucoCorners, InputArray charucoIds,
                                            const Ptr<CharucoBoard> &board, InputArray cameraMatrix,
@@ -275,6 +276,7 @@ CV_EXPORTS_W double calibrateCameraCharuco(
  * 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
@@ -285,7 +287,8 @@ CV_EXPORTS_W void detectCharucoDiamond(InputArray image, InputArrayOfArrays mark
                                        InputArray markerIds, float squareMarkerLengthRate,
                                        OutputArrayOfArrays diamondCorners, OutputArray diamondIds,
                                        InputArray cameraMatrix = noArray(),
-                                       InputArray distCoeffs = noArray());
+                                       InputArray distCoeffs = noArray(),
+                                       Ptr<Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::PREDEFINED_DICTIONARY_NAME::DICT_4X4_50));
 
 
 

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

@@ -94,15 +94,20 @@ class CV_EXPORTS_W Dictionary {
             const Ptr<Dictionary> &baseDictionary, int randomSeed=0);
 
     /**
-     * @brief Read a new dictionary from FileNode. Format:
-     * nmarkers: 35
-     * markersize: 6
-     * marker_0: "101011111011111001001001101100000000"
-     * ...
+     * @brief Read a new dictionary from FileNode. Format:\n
+     * nmarkers: 35\n
+     * markersize: 6\n
+     * maxCorrectionBits: 5\n
+     * marker_0: "101011111011111001001001101100000000"\n
+     * ...\n
      * marker_34: "011111010000111011111110110101100101"
      */
-    CV_WRAP static bool readDictionary(const cv::FileNode& fn, cv::Ptr<cv::aruco::Dictionary> &dictionary);
+    CV_WRAP bool readDictionary(const cv::FileNode& fn);
 
+    /**
+     * @brief Write a dictionary to FileStorage. Format is the same as in readDictionary().
+     */
+    CV_WRAP void writeDictionary(Ptr<FileStorage>& fs);
     /**
      * @see getPredefinedDictionary
      */
@@ -149,23 +154,23 @@ class CV_EXPORTS_W Dictionary {
                           distance
  */
 enum PREDEFINED_DICTIONARY_NAME {
-    DICT_4X4_50 = 0,
-    DICT_4X4_100,
-    DICT_4X4_250,
-    DICT_4X4_1000,
-    DICT_5X5_50,
-    DICT_5X5_100,
-    DICT_5X5_250,
-    DICT_5X5_1000,
-    DICT_6X6_50,
-    DICT_6X6_100,
-    DICT_6X6_250,
-    DICT_6X6_1000,
-    DICT_7X7_50,
-    DICT_7X7_100,
-    DICT_7X7_250,
-    DICT_7X7_1000,
-    DICT_ARUCO_ORIGINAL,
+    DICT_4X4_50 = 0,        ///< 4x4 bits, minimum hamming distance between any two codes = 4, 50 codes
+    DICT_4X4_100,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 100 codes
+    DICT_4X4_250,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 250 codes
+    DICT_4X4_1000,          ///< 4x4 bits, minimum hamming distance between any two codes = 2, 1000 codes
+    DICT_5X5_50,            ///< 5x5 bits, minimum hamming distance between any two codes = 8, 50 codes
+    DICT_5X5_100,           ///< 5x5 bits, minimum hamming distance between any two codes = 7, 100 codes
+    DICT_5X5_250,           ///< 5x5 bits, minimum hamming distance between any two codes = 6, 250 codes
+    DICT_5X5_1000,          ///< 5x5 bits, minimum hamming distance between any two codes = 5, 1000 codes
+    DICT_6X6_50,            ///< 6x6 bits, minimum hamming distance between any two codes = 13, 50 codes
+    DICT_6X6_100,           ///< 6x6 bits, minimum hamming distance between any two codes = 12, 100 codes
+    DICT_6X6_250,           ///< 6x6 bits, minimum hamming distance between any two codes = 11, 250 codes
+    DICT_6X6_1000,          ///< 6x6 bits, minimum hamming distance between any two codes = 9, 1000 codes
+    DICT_7X7_50,            ///< 7x7 bits, minimum hamming distance between any two codes = 19, 50 codes
+    DICT_7X7_100,           ///< 7x7 bits, minimum hamming distance between any two codes = 18, 100 codes
+    DICT_7X7_250,           ///< 7x7 bits, minimum hamming distance between any two codes = 17, 250 codes
+    DICT_7X7_1000,          ///< 7x7 bits, minimum hamming distance between any two codes = 14, 1000 codes
+    DICT_ARUCO_ORIGINAL,    ///< 6x6 bits, minimum hamming distance between any two codes = 3, 1024 codes
     DICT_APRILTAG_16h5,     ///< 4x4 bits, minimum hamming distance between any two codes = 5, 30 codes
     DICT_APRILTAG_25h9,     ///< 5x5 bits, minimum hamming distance between any two codes = 9, 35 codes
     DICT_APRILTAG_36h10,    ///< 6x6 bits, minimum hamming distance between any two codes = 10, 2320 codes

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

@@ -35,5 +35,35 @@ def test_drawCharucoDiamond(self):
         img = cv.aruco.drawCharucoDiamond(aruco_dict, np.array([0, 1, 2, 3]), 100, 80)
         self.assertTrue(img is not None)
 
+    def test_write_read_dict(self):
+
+        try:
+            aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_5X5_50)
+            markers_gold = aruco_dict.bytesList
+
+            # write aruco_dict
+            filename = "test_dict.yml"
+            fs_write = cv.FileStorage(filename, cv.FileStorage_WRITE)
+            aruco_dict.writeDictionary(fs_write)
+            fs_write.release()
+
+            # reset aruco_dict
+            aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_250)
+
+            # read aruco_dict
+            fs_read = cv.FileStorage(filename, cv.FileStorage_READ)
+            aruco_dict.readDictionary(fs_read.root())
+            fs_read.release()
+
+            # check equal
+            self.assertEqual(aruco_dict.markerSize, 5)
+            self.assertEqual(aruco_dict.maxCorrectionBits, 3)
+            np.testing.assert_array_equal(aruco_dict.bytesList, markers_gold)
+
+        finally:
+            if os.path.exists(filename):
+                os.remove(filename)
+
+
 if __name__ == '__main__':
     NewOpenCVTests.bootstrap()