Package org.opencv.objdetect

## Class ArucoDetector

- java.lang.Object
- - org.opencv.core.Algorithm
  - - org.opencv.objdetect.ArucoDetector

-     public class ArucoDetector
      extends Algorithm

  The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method. After detecting some markers in the image, you can try to find undetected markers from this dictionary with refineDetectedMarkers() method. SEE: DetectorParameters, RefineParameters

- - ### Field Summary

    - ### Fields inherited from class org.opencv.core.Algorithm

      `nativeObj`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `` | `ArucoDetector()` | Basic ArucoDetector constructor
    `protected` | `ArucoDetector​(long addr)` |
    `` | `ArucoDetector​(Dictionary dictionary)` | Basic ArucoDetector constructor
    `` | `ArucoDetector​(Dictionary dictionary, DetectorParameters detectorParams)` | Basic ArucoDetector constructor
    `` | `ArucoDetector​(Dictionary dictionary, DetectorParameters detectorParams, RefineParameters refineParams)` | Basic ArucoDetector constructor

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static ArucoDetector` | `__fromPtr__​(long addr)` |
    `void` | `detectMarkers​(Mat image, java.util.List<Mat> corners, Mat ids)` | Basic marker detection
    `void` | `detectMarkers​(Mat image, java.util.List<Mat> corners, Mat ids, java.util.List<Mat> rejectedImgPoints)` | Basic marker detection
    `protected void` | `finalize()` |
    `DetectorParameters` | `getDetectorParameters()` |
    `Dictionary` | `getDictionary()` |
    `RefineParameters` | `getRefineParameters()` |
    `void` | `refineDetectedMarkers​(Mat image, Board board, java.util.List<Mat> detectedCorners, Mat detectedIds, java.util.List<Mat> rejectedCorners)` | Refine not detected markers based on the already detected and the board layout
    `void` | `refineDetectedMarkers​(Mat image, Board board, java.util.List<Mat> detectedCorners, Mat detectedIds, java.util.List<Mat> rejectedCorners, Mat cameraMatrix)` | Refine not detected markers based on the already detected and the board layout
    `void` | `refineDetectedMarkers​(Mat image, Board board, java.util.List<Mat> detectedCorners, Mat detectedIds, java.util.List<Mat> rejectedCorners, Mat cameraMatrix, Mat distCoeffs)` | Refine not detected markers based on the already detected and the board layout
    `void` | `refineDetectedMarkers​(Mat image, Board board, java.util.List<Mat> detectedCorners, Mat detectedIds, java.util.List<Mat> rejectedCorners, Mat cameraMatrix, Mat distCoeffs, Mat recoveredIdxs)` | Refine not detected markers based on the already detected and the board layout
    `void` | `setDetectorParameters​(DetectorParameters detectorParameters)` |
    `void` | `setDictionary​(Dictionary dictionary)` |
    `void` | `setRefineParameters​(RefineParameters refineParameters)` |

    - ### Methods inherited from class org.opencv.core.Algorithm

      `clear, empty, getDefaultName, getNativeObjAddr, save`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ArucoDetector

          protected ArucoDetector​(long addr)

    - #### ArucoDetector

          public ArucoDetector​(Dictionary dictionary,
                               DetectorParameters detectorParams,
                               RefineParameters refineParams)

      Basic ArucoDetector constructor
      Parameters:
        `dictionary` - indicates the type of markers that will be searched
        `detectorParams` - marker detection parameters
        `refineParams` - marker refine detection parameters

    - #### ArucoDetector

          public ArucoDetector​(Dictionary dictionary,
                               DetectorParameters detectorParams)

      Basic ArucoDetector constructor
      Parameters:
        `dictionary` - indicates the type of markers that will be searched
        `detectorParams` - marker detection parameters

    - #### ArucoDetector

          public ArucoDetector​(Dictionary dictionary)

      Basic ArucoDetector constructor
      Parameters:
        `dictionary` - indicates the type of markers that will be searched

    - #### ArucoDetector

          public ArucoDetector()

      Basic ArucoDetector constructor

  - ### Method Detail

    - #### __fromPtr__

          public static ArucoDetector __fromPtr__​(long addr)

    - #### detectMarkers

          public void detectMarkers​(Mat image,
                                    java.util.List<Mat> corners,
                                    Mat ids,
                                    java.util.List<Mat> rejectedImgPoints)

      Basic marker detection
      Parameters:
        `image` - input image
        `corners` - vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array is Nx4. The order of the corners is clockwise.
        `ids` - vector of identifiers of the detected markers. The identifier is of type int (e.g. std::vector<int>). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array.
        `rejectedImgPoints` - contains the imgPoints of those squares whose inner code has not a correct codification. Useful for debugging purposes. 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. Note: The function does not correct lens distortion or takes it into account. It's recommended to undistort input image with corresponding camera model, if camera parameters are known SEE: undistort, estimatePoseSingleMarkers, estimatePoseBoard

    - #### detectMarkers

          public void detectMarkers​(Mat image,
                                    java.util.List<Mat> corners,
                                    Mat ids)

      Basic marker detection
      Parameters:
        `image` - input image
        `corners` - vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array is Nx4. The order of the corners is clockwise.
        `ids` - vector of identifiers of the detected markers. The identifier is of type int (e.g. std::vector<int>). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array. correct codification. Useful for debugging purposes. 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. Note: The function does not correct lens distortion or takes it into account. It's recommended to undistort input image with corresponding camera model, if camera parameters are known SEE: undistort, estimatePoseSingleMarkers, estimatePoseBoard

    - #### refineDetectedMarkers

          public void refineDetectedMarkers​(Mat image,
                                            Board board,
                                            java.util.List<Mat> detectedCorners,
                                            Mat detectedIds,
                                            java.util.List<Mat> rejectedCorners,
                                            Mat cameraMatrix,
                                            Mat distCoeffs,
                                            Mat recoveredIdxs)

      Refine not detected markers based on the already detected and the board layout
      Parameters:
        `image` - input image
        `board` - layout of markers in the board.
        `detectedCorners` - vector of already detected marker corners.
        `detectedIds` - vector of already detected marker identifiers.
        `rejectedCorners` - vector of rejected candidates during the marker detection process.
        `cameraMatrix` - optional input 3x3 floating-point camera matrix \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\)
        `distCoeffs` - optional vector of distortion coefficients \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\) of 4, 5, 8 or 12 elements
        `recoveredIdxs` - Optional array to returns the indexes of the recovered candidates in the original rejectedCorners array. This function tries to find markers that were not detected in the basic detecMarkers function. First, based on the current detected marker and the board layout, the function interpolates the position of the missing markers. Then it tries to find correspondence between the reprojected markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters. If camera parameters and distortion coefficients are provided, missing markers are reprojected using projectPoint function. If not, missing marker projections are interpolated using global homography, and all the marker corners in the board must have the same Z coordinate.

    - #### refineDetectedMarkers

          public void refineDetectedMarkers​(Mat image,
                                            Board board,
                                            java.util.List<Mat> detectedCorners,
                                            Mat detectedIds,
                                            java.util.List<Mat> rejectedCorners,
                                            Mat cameraMatrix,
                                            Mat distCoeffs)

      Refine not detected markers based on the already detected and the board layout
      Parameters:
        `image` - input image
        `board` - layout of markers in the board.
        `detectedCorners` - vector of already detected marker corners.
        `detectedIds` - vector of already detected marker identifiers.
        `rejectedCorners` - vector of rejected candidates during the marker detection process.
        `cameraMatrix` - optional input 3x3 floating-point camera matrix \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\)
        `distCoeffs` - optional vector of distortion coefficients \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\) of 4, 5, 8 or 12 elements original rejectedCorners array. This function tries to find markers that were not detected in the basic detecMarkers function. First, based on the current detected marker and the board layout, the function interpolates the position of the missing markers. Then it tries to find correspondence between the reprojected markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters. If camera parameters and distortion coefficients are provided, missing markers are reprojected using projectPoint function. If not, missing marker projections are interpolated using global homography, and all the marker corners in the board must have the same Z coordinate.

    - #### refineDetectedMarkers

          public void refineDetectedMarkers​(Mat image,
                                            Board board,
                                            java.util.List<Mat> detectedCorners,
                                            Mat detectedIds,
                                            java.util.List<Mat> rejectedCorners,
                                            Mat cameraMatrix)

      Refine not detected markers based on the already detected and the board layout
      Parameters:
        `image` - input image
        `board` - layout of markers in the board.
        `detectedCorners` - vector of already detected marker corners.
        `detectedIds` - vector of already detected marker identifiers.
        `rejectedCorners` - vector of rejected candidates during the marker detection process.
        `cameraMatrix` - optional input 3x3 floating-point camera matrix \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\) of 4, 5, 8 or 12 elements original rejectedCorners array. This function tries to find markers that were not detected in the basic detecMarkers function. First, based on the current detected marker and the board layout, the function interpolates the position of the missing markers. Then it tries to find correspondence between the reprojected markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters. If camera parameters and distortion coefficients are provided, missing markers are reprojected using projectPoint function. If not, missing marker projections are interpolated using global homography, and all the marker corners in the board must have the same Z coordinate.

    - #### refineDetectedMarkers

          public void refineDetectedMarkers​(Mat image,
                                            Board board,
                                            java.util.List<Mat> detectedCorners,
                                            Mat detectedIds,
                                            java.util.List<Mat> rejectedCorners)

      Refine not detected markers based on the already detected and the board layout
      Parameters:
        `image` - input image
        `board` - layout of markers in the board.
        `detectedCorners` - vector of already detected marker corners.
        `detectedIds` - vector of already detected marker identifiers.
        `rejectedCorners` - vector of rejected candidates during the marker detection process. \(A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\) \((k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\) of 4, 5, 8 or 12 elements original rejectedCorners array. This function tries to find markers that were not detected in the basic detecMarkers function. First, based on the current detected marker and the board layout, the function interpolates the position of the missing markers. Then it tries to find correspondence between the reprojected markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters. If camera parameters and distortion coefficients are provided, missing markers are reprojected using projectPoint function. If not, missing marker projections are interpolated using global homography, and all the marker corners in the board must have the same Z coordinate.

    - #### getDictionary

          public Dictionary getDictionary()

    - #### setDictionary

          public void setDictionary​(Dictionary dictionary)

    - #### getDetectorParameters

          public DetectorParameters getDetectorParameters()

    - #### setDetectorParameters

          public void setDetectorParameters​(DetectorParameters detectorParameters)

    - #### getRefineParameters

          public RefineParameters getRefineParameters()

    - #### setRefineParameters

          public void setRefineParameters​(RefineParameters refineParameters)

    - #### finalize

          protected void finalize()
                           throws java.lang.Throwable

      Overrides:
        `finalize` in class `Algorithm`
      Throws:
        `java.lang.Throwable`