opencv_aruco (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_aruco
- - org.bytedeco.opencv.global.opencv_aruco

All Implemented Interfaces:: InfoMapper

public class opencv_aruco
extends opencv_aruco

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CORNER_REFINE_APRILTAG` enum cv::aruco::CornerRefineMethod
`static int`	`CORNER_REFINE_CONTOUR` enum cv::aruco::CornerRefineMethod
`static int`	`CORNER_REFINE_NONE` enum cv::aruco::CornerRefineMethod
`static int`	`CORNER_REFINE_SUBPIX` enum cv::aruco::CornerRefineMethod
`static int`	`DICT_4X4_100` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_4X4_1000` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_4X4_250` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_4X4_50` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_5X5_100` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_5X5_1000` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_5X5_250` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_5X5_50` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_6X6_100` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_6X6_1000` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_6X6_250` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_6X6_50` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_7X7_100` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_7X7_1000` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_7X7_250` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_7X7_50` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_APRILTAG_16h5` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_APRILTAG_25h9` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_APRILTAG_36h10` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_APRILTAG_36h11` enum cv::aruco::PREDEFINED_DICTIONARY_NAME
`static int`	`DICT_ARUCO_ORIGINAL` enum cv::aruco::PREDEFINED_DICTIONARY_NAME

Constructor Summary

Constructors
Constructor and Description

opencv_aruco()

Constructors
Constructor and Description
`opencv_aruco()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static double`	`calibrateCameraAruco(GpuMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraAruco(GpuMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraAruco(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(GpuMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraAruco(GpuMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(MatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraAruco(MatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraAruco(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)` \brief It's the same function as #calibrateCameraAruco but without calibration error estimation.
`static double`	`calibrateCameraAruco(MatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraAruco(MatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(UMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraAruco(UMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraAruco(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraAruco(UMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraAruco(UMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(GpuMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(MatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(MatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Calibrate a camera using aruco markers
`static double`	`calibrateCameraArucoExtended(MatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(MatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, GpuMat ids, GpuMat counter, Board board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraArucoExtended(UMatVector corners, UMat ids, UMat counter, Board board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)` \brief It's the same function as #calibrateCameraCharuco but without calibration error estimation.
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs)`
`static double`	`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, MatVector rvecs, MatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Calibrate a camera using Charuco corners
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, MatVector rvecs, MatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, GpuMat cameraMatrix, GpuMat distCoeffs, UMatVector rvecs, UMatVector tvecs, GpuMat stdDeviationsIntrinsics, GpuMat stdDeviationsExtrinsics, GpuMat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors)`
`static double`	`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, UMat cameraMatrix, UMat distCoeffs, UMatVector rvecs, UMatVector tvecs, UMat stdDeviationsIntrinsics, UMat stdDeviationsExtrinsics, UMat perViewErrors, int flags, TermCriteria criteria)`
`static Dictionary`	`custom_dictionary_from(int nMarkers, int markerSize, Dictionary baseDictionary)`
`static Dictionary`	`custom_dictionary_from(int nMarkers, int markerSize, Dictionary baseDictionary, int randomSeed)` \brief Generates a new customizable marker dictionary
`static Dictionary`	`custom_dictionary(int nMarkers, int markerSize)`
`static Dictionary`	`custom_dictionary(int nMarkers, int markerSize, int randomSeed)`
`static void`	`detectCharucoDiamond(GpuMat image, GpuMatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, GpuMat diamondIds)`
`static void`	`detectCharucoDiamond(GpuMat image, GpuMatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, GpuMat diamondIds, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static void`	`detectCharucoDiamond(GpuMat image, MatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, GpuMat diamondIds)`
`static void`	`detectCharucoDiamond(GpuMat image, MatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, GpuMat diamondIds, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static void`	`detectCharucoDiamond(GpuMat image, UMatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, GpuMat diamondIds)`
`static void`	`detectCharucoDiamond(GpuMat image, UMatVector markerCorners, GpuMat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, GpuMat diamondIds, GpuMat cameraMatrix, GpuMat distCoeffs)`
`static void`	`detectCharucoDiamond(Mat image, GpuMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, Mat diamondIds)`
`static void`	`detectCharucoDiamond(Mat image, GpuMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)`
`static void`	`detectCharucoDiamond(Mat image, MatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, Mat diamondIds)`
`static void`	`detectCharucoDiamond(Mat image, MatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)` \brief Detect ChArUco Diamond markers
`static void`	`detectCharucoDiamond(Mat image, UMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, Mat diamondIds)`
`static void`	`detectCharucoDiamond(Mat image, UMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)`
`static void`	`detectCharucoDiamond(UMat image, GpuMatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, UMat diamondIds)`
`static void`	`detectCharucoDiamond(UMat image, GpuMatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, UMat diamondIds, UMat cameraMatrix, UMat distCoeffs)`
`static void`	`detectCharucoDiamond(UMat image, MatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, UMat diamondIds)`
`static void`	`detectCharucoDiamond(UMat image, MatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, UMat diamondIds, UMat cameraMatrix, UMat distCoeffs)`
`static void`	`detectCharucoDiamond(UMat image, UMatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, UMat diamondIds)`
`static void`	`detectCharucoDiamond(UMat image, UMatVector markerCorners, UMat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, UMat diamondIds, UMat cameraMatrix, UMat distCoeffs)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, GpuMatVector corners, GpuMat ids)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, GpuMatVector corners, GpuMat ids, DetectorParameters parameters, GpuMatVector rejectedImgPoints, GpuMat cameraMatrix, GpuMat distCoeff)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, MatVector corners, GpuMat ids)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, MatVector corners, GpuMat ids, DetectorParameters parameters, MatVector rejectedImgPoints, GpuMat cameraMatrix, GpuMat distCoeff)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, UMatVector corners, GpuMat ids)`
`static void`	`detectMarkers(GpuMat image, Dictionary dictionary, UMatVector corners, GpuMat ids, DetectorParameters parameters, UMatVector rejectedImgPoints, GpuMat cameraMatrix, GpuMat distCoeff)`
`static void`	`detectMarkers(Mat image, Dictionary dictionary, GpuMatVector corners, Mat ids)`
`static void`	`detectMarkers(Mat image, Dictionary dictionary, GpuMatVector corners, Mat ids, DetectorParameters parameters, GpuMatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)`
`static void`	`detectMarkers(Mat image, Dictionary dictionary, MatVector corners, Mat ids)`
`static void`	`detectMarkers(Mat image, Dictionary dictionary, MatVector corners, Mat ids, DetectorParameters parameters, MatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)` \brief Basic marker detection
`static void`	`detectMarkers(Mat image, Dictionary dictionary, UMatVector corners, Mat ids)`
`static void`	`detectMarkers(Mat image, Dictionary dictionary, UMatVector corners, Mat ids, DetectorParameters parameters, UMatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, GpuMatVector corners, UMat ids)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, GpuMatVector corners, UMat ids, DetectorParameters parameters, GpuMatVector rejectedImgPoints, UMat cameraMatrix, UMat distCoeff)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, MatVector corners, UMat ids)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, MatVector corners, UMat ids, DetectorParameters parameters, MatVector rejectedImgPoints, UMat cameraMatrix, UMat distCoeff)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, UMatVector corners, UMat ids)`
`static void`	`detectMarkers(UMat image, Dictionary dictionary, UMatVector corners, UMat ids, DetectorParameters parameters, UMatVector rejectedImgPoints, UMat cameraMatrix, UMat distCoeff)`
`static void`	`drawAxis(GpuMat image, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec, float length)`
`static void`	`drawAxis(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)` Deprecated. use cv::drawFrameAxes
`static void`	`drawAxis(UMat image, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec, float length)`
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, GpuMat img)`
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, GpuMat img, int marginSize, int borderBits)`
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, Mat img)`
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, Mat img, int marginSize, int borderBits)` \brief Draw a ChArUco Diamond marker
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, UMat img)`
`static void`	`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, UMat img, int marginSize, int borderBits)`
`static void`	`drawDetectedCornersCharuco(GpuMat image, GpuMat charucoCorners)`
`static void`	`drawDetectedCornersCharuco(GpuMat image, GpuMat charucoCorners, GpuMat charucoIds, Scalar cornerColor)`
`static void`	`drawDetectedCornersCharuco(Mat image, Mat charucoCorners)`
`static void`	`drawDetectedCornersCharuco(Mat image, Mat charucoCorners, Mat charucoIds, Scalar cornerColor)` \brief Draws a set of Charuco corners
`static void`	`drawDetectedCornersCharuco(UMat image, UMat charucoCorners)`
`static void`	`drawDetectedCornersCharuco(UMat image, UMat charucoCorners, UMat charucoIds, Scalar cornerColor)`
`static void`	`drawDetectedDiamonds(GpuMat image, GpuMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(GpuMat image, GpuMatVector diamondCorners, GpuMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(GpuMat image, MatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(GpuMat image, MatVector diamondCorners, GpuMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(GpuMat image, UMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(GpuMat image, UMatVector diamondCorners, GpuMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(Mat image, GpuMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(Mat image, GpuMatVector diamondCorners, Mat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(Mat image, MatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(Mat image, MatVector diamondCorners, Mat diamondIds, Scalar borderColor)` \brief Draw a set of detected ChArUco Diamond markers
`static void`	`drawDetectedDiamonds(Mat image, UMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(Mat image, UMatVector diamondCorners, Mat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(UMat image, GpuMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(UMat image, GpuMatVector diamondCorners, UMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(UMat image, MatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(UMat image, MatVector diamondCorners, UMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedDiamonds(UMat image, UMatVector diamondCorners)`
`static void`	`drawDetectedDiamonds(UMat image, UMatVector diamondCorners, UMat diamondIds, Scalar borderColor)`
`static void`	`drawDetectedMarkers(GpuMat image, GpuMatVector corners)`
`static void`	`drawDetectedMarkers(GpuMat image, GpuMatVector corners, GpuMat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(GpuMat image, MatVector corners)`
`static void`	`drawDetectedMarkers(GpuMat image, MatVector corners, GpuMat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(GpuMat image, UMatVector corners)`
`static void`	`drawDetectedMarkers(GpuMat image, UMatVector corners, GpuMat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(Mat image, GpuMatVector corners)`
`static void`	`drawDetectedMarkers(Mat image, GpuMatVector corners, Mat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(Mat image, MatVector corners)`
`static void`	`drawDetectedMarkers(Mat image, MatVector corners, Mat ids, Scalar borderColor)` \brief Draw detected markers in image
`static void`	`drawDetectedMarkers(Mat image, UMatVector corners)`
`static void`	`drawDetectedMarkers(Mat image, UMatVector corners, Mat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(UMat image, GpuMatVector corners)`
`static void`	`drawDetectedMarkers(UMat image, GpuMatVector corners, UMat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(UMat image, MatVector corners)`
`static void`	`drawDetectedMarkers(UMat image, MatVector corners, UMat ids, Scalar borderColor)`
`static void`	`drawDetectedMarkers(UMat image, UMatVector corners)`
`static void`	`drawDetectedMarkers(UMat image, UMatVector corners, UMat ids, Scalar borderColor)`
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, GpuMat img)`
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, GpuMat img, int borderBits)`
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, Mat img)`
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, Mat img, int borderBits)` \brief Draw a canonical marker image
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, UMat img)`
`static void`	`drawMarker(Dictionary dictionary, int id, int sidePixels, UMat img, int borderBits)`
`static void`	`drawPlanarBoard(Board board, Size outSize, GpuMat img)`
`static void`	`drawPlanarBoard(Board board, Size outSize, GpuMat img, int marginSize, int borderBits)`
`static void`	`drawPlanarBoard(Board board, Size outSize, Mat img)`
`static void`	`drawPlanarBoard(Board board, Size outSize, Mat img, int marginSize, int borderBits)` \brief Draw a planar board
`static void`	`drawPlanarBoard(Board board, Size outSize, UMat img)`
`static void`	`drawPlanarBoard(Board board, Size outSize, UMat img, int marginSize, int borderBits)`
`static int`	`estimatePoseBoard(GpuMatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec)`
`static int`	`estimatePoseBoard(GpuMatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(GpuMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	`estimatePoseBoard(GpuMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(GpuMatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec)`
`static int`	`estimatePoseBoard(GpuMatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(MatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec)`
`static int`	`estimatePoseBoard(MatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(MatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	`estimatePoseBoard(MatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)` \brief Pose estimation for a board of markers
`static int`	`estimatePoseBoard(MatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec)`
`static int`	`estimatePoseBoard(MatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(UMatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec)`
`static int`	`estimatePoseBoard(UMatVector corners, GpuMat ids, Board board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(UMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	`estimatePoseBoard(UMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
`static int`	`estimatePoseBoard(UMatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec)`
`static int`	`estimatePoseBoard(UMatVector corners, UMat ids, Board board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec, boolean useExtrinsicGuess)`
`static boolean`	`estimatePoseCharucoBoard(GpuMat charucoCorners, GpuMat charucoIds, CharucoBoard board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec)`
`static boolean`	`estimatePoseCharucoBoard(GpuMat charucoCorners, GpuMat charucoIds, CharucoBoard board, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvec, GpuMat tvec, boolean useExtrinsicGuess)`
`static boolean`	`estimatePoseCharucoBoard(Mat charucoCorners, Mat charucoIds, CharucoBoard board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static boolean`	`estimatePoseCharucoBoard(Mat charucoCorners, Mat charucoIds, CharucoBoard board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)` \brief Pose estimation for a ChArUco board given some of their corners
`static boolean`	`estimatePoseCharucoBoard(UMat charucoCorners, UMat charucoIds, CharucoBoard board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec)`
`static boolean`	`estimatePoseCharucoBoard(UMat charucoCorners, UMat charucoIds, CharucoBoard board, UMat cameraMatrix, UMat distCoeffs, UMat rvec, UMat tvec, boolean useExtrinsicGuess)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs, GpuMat _objPoints)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs)`
`static void`	`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs, UMat _objPoints)`
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs)`
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs, GpuMat _objPoints)`
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)` \brief Pose estimation for single markers
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs)`
`static void`	`estimatePoseSingleMarkers(MatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs, UMat _objPoints)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, GpuMat cameraMatrix, GpuMat distCoeffs, GpuMat rvecs, GpuMat tvecs, GpuMat _objPoints)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs)`
`static void`	`estimatePoseSingleMarkers(UMatVector corners, float markerLength, UMat cameraMatrix, UMat distCoeffs, UMat rvecs, UMat tvecs, UMat _objPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, GpuMatVector detectedCorners, GpuMat detectedIds, GpuMat objPoints, GpuMat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, GpuMatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, GpuMatVector detectedCorners, UMat detectedIds, UMat objPoints, UMat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, MatVector detectedCorners, GpuMat detectedIds, GpuMat objPoints, GpuMat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, MatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)` \brief Given a board configuration and a set of detected markers, returns the corresponding image points and object points to call solvePnP
`static void`	`getBoardObjectAndImagePoints(Board board, MatVector detectedCorners, UMat detectedIds, UMat objPoints, UMat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, UMatVector detectedCorners, GpuMat detectedIds, GpuMat objPoints, GpuMat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, UMatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)`
`static void`	`getBoardObjectAndImagePoints(Board board, UMatVector detectedCorners, UMat detectedIds, UMat objPoints, UMat imgPoints)`
`static Dictionary`	`getPredefinedDictionary(int name)` \brief Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds)`
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds, GpuMat cameraMatrix, GpuMat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds)`
`static int`	`interpolateCornersCharuco(GpuMatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds, UMat cameraMatrix, UMat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(MatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds)`
`static int`	`interpolateCornersCharuco(MatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds, GpuMat cameraMatrix, GpuMat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(MatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	`interpolateCornersCharuco(MatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)` \brief Interpolate position of ChArUco board corners
`static int`	`interpolateCornersCharuco(MatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds)`
`static int`	`interpolateCornersCharuco(MatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds, UMat cameraMatrix, UMat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, GpuMat markerIds, GpuMat image, CharucoBoard board, GpuMat charucoCorners, GpuMat charucoIds, GpuMat cameraMatrix, GpuMat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds)`
`static int`	`interpolateCornersCharuco(UMatVector markerCorners, UMat markerIds, UMat image, CharucoBoard board, UMat charucoCorners, UMat charucoIds, UMat cameraMatrix, UMat distCoeffs, int minMarkers)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, GpuMatVector detectedCorners, GpuMat detectedIds, GpuMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, GpuMatVector detectedCorners, GpuMat detectedIds, GpuMatVector rejectedCorners, GpuMat cameraMatrix, GpuMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, GpuMat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, MatVector detectedCorners, GpuMat detectedIds, MatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, MatVector detectedCorners, GpuMat detectedIds, MatVector rejectedCorners, GpuMat cameraMatrix, GpuMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, GpuMat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, UMatVector detectedCorners, GpuMat detectedIds, UMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(GpuMat image, Board board, UMatVector detectedCorners, GpuMat detectedIds, UMatVector rejectedCorners, GpuMat cameraMatrix, GpuMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, GpuMat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(Mat image, Board board, GpuMatVector detectedCorners, Mat detectedIds, GpuMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(Mat image, Board board, GpuMatVector detectedCorners, Mat detectedIds, GpuMatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(Mat image, Board board, MatVector detectedCorners, Mat detectedIds, MatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(Mat image, Board board, MatVector detectedCorners, Mat detectedIds, MatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)` \brief Refind not detected markers based on the already detected and the board layout
`static void`	`refineDetectedMarkers(Mat image, Board board, UMatVector detectedCorners, Mat detectedIds, UMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(Mat image, Board board, UMatVector detectedCorners, Mat detectedIds, UMatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(UMat image, Board board, GpuMatVector detectedCorners, UMat detectedIds, GpuMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(UMat image, Board board, GpuMatVector detectedCorners, UMat detectedIds, GpuMatVector rejectedCorners, UMat cameraMatrix, UMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, UMat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(UMat image, Board board, MatVector detectedCorners, UMat detectedIds, MatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(UMat image, Board board, MatVector detectedCorners, UMat detectedIds, MatVector rejectedCorners, UMat cameraMatrix, UMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, UMat recoveredIdxs, DetectorParameters parameters)`
`static void`	`refineDetectedMarkers(UMat image, Board board, UMatVector detectedCorners, UMat detectedIds, UMatVector rejectedCorners)`
`static void`	`refineDetectedMarkers(UMat image, Board board, UMatVector detectedCorners, UMat detectedIds, UMatVector rejectedCorners, UMat cameraMatrix, UMat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, UMat recoveredIdxs, DetectorParameters parameters)`

Methods inherited from class org.bytedeco.opencv.presets.opencv_aruco
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- DICT_4X4_50
```
public static final int DICT_4X4_50
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_4X4_100
```
public static final int DICT_4X4_100
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_4X4_250
```
public static final int DICT_4X4_250
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_4X4_1000
```
public static final int DICT_4X4_1000
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_5X5_50
```
public static final int DICT_5X5_50
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_5X5_100
```
public static final int DICT_5X5_100
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_5X5_250
```
public static final int DICT_5X5_250
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_5X5_1000
```
public static final int DICT_5X5_1000
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_6X6_50
```
public static final int DICT_6X6_50
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_6X6_100
```
public static final int DICT_6X6_100
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_6X6_250
```
public static final int DICT_6X6_250
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_6X6_1000
```
public static final int DICT_6X6_1000
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_7X7_50
```
public static final int DICT_7X7_50
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_7X7_100
```
public static final int DICT_7X7_100
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_7X7_250
```
public static final int DICT_7X7_250
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_7X7_1000
```
public static final int DICT_7X7_1000
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_ARUCO_ORIGINAL
```
public static final int DICT_ARUCO_ORIGINAL
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_APRILTAG_16h5
```
public static final int DICT_APRILTAG_16h5
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_APRILTAG_25h9
```
public static final int DICT_APRILTAG_25h9
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_APRILTAG_36h10
```
public static final int DICT_APRILTAG_36h10
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- DICT_APRILTAG_36h11
```
public static final int DICT_APRILTAG_36h11
```
  enum cv::aruco::PREDEFINED_DICTIONARY_NAME
  
  See Also:
  
  Constant Field Values
- CORNER_REFINE_NONE
```
public static final int CORNER_REFINE_NONE
```
  enum cv::aruco::CornerRefineMethod
  
  See Also:
  
  Constant Field Values
- CORNER_REFINE_SUBPIX
```
public static final int CORNER_REFINE_SUBPIX
```
  enum cv::aruco::CornerRefineMethod
  
  See Also:
  
  Constant Field Values
- CORNER_REFINE_CONTOUR
```
public static final int CORNER_REFINE_CONTOUR
```
  enum cv::aruco::CornerRefineMethod
  
  See Also:
  
  Constant Field Values
- CORNER_REFINE_APRILTAG
```
public static final int CORNER_REFINE_APRILTAG
```
  enum cv::aruco::CornerRefineMethod
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_aruco
```
public opencv_aruco()
```

Method Detail

getPredefinedDictionary

@Namespace(value="cv::aruco")
 @opencv_core.Ptr
public static Dictionary getPredefinedDictionary(@Cast(value="cv::aruco::PREDEFINED_DICTIONARY_NAME")
                                                                                                 int name)

\brief Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME

custom_dictionary

@Namespace(value="cv::aruco")
 @opencv_core.Ptr
 @Name(value="generateCustomDictionary")
public static Dictionary custom_dictionary(int nMarkers,
                                                                                                                                    int markerSize,
                                                                                                                                    int randomSeed)

See Also:: generateCustomDictionary

custom_dictionary

@Namespace(value="cv::aruco")
 @opencv_core.Ptr
 @Name(value="generateCustomDictionary")
public static Dictionary custom_dictionary(int nMarkers,
                                                                                                                                    int markerSize)

custom_dictionary_from

@Namespace(value="cv::aruco")
 @opencv_core.Ptr
 @Name(value="generateCustomDictionary")
public static Dictionary custom_dictionary_from(int nMarkers,
                                                                                                                                         int markerSize,
                                                                                                                                         @opencv_core.Ptr
                                                                                                                                         Dictionary baseDictionary,
                                                                                                                                         int randomSeed)

\brief Generates a new customizable marker dictionary

Parameters:: nMarkers - number of markers in the dictionary; markerSize - number of bits per dimension of each markers; baseDictionary - Include the markers in this dictionary at the beginning (optional); randomSeed - a user supplied seed for theRNG() This function creates a new dictionary composed by nMarkers markers and each markers composed by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly included and the rest are generated based on them. If the size of baseDictionary is higher than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.

custom_dictionary_from

@Namespace(value="cv::aruco")
 @opencv_core.Ptr
 @Name(value="generateCustomDictionary")
public static Dictionary custom_dictionary_from(int nMarkers,
                                                                                                                                         int markerSize,
                                                                                                                                         @opencv_core.Ptr
                                                                                                                                         Dictionary baseDictionary)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               Mat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               MatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat distCoeff)

\brief Basic marker detection

Parameters:: image - input image; dictionary - indicates the type of markers that will be searched; corners - vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector > ). 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). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array.; parameters - marker detection parameters; rejectedImgPoints - contains the imgPoints of those squares whose inner code has not a correct codification. Useful for debugging purposes.; cameraMatrix - optional input 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}; distCoeff - 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 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.
See Also:: estimatePoseSingleMarkers, estimatePoseBoard

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               Mat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               Mat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               UMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               Mat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               Mat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               GpuMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               Mat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               Mat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               Mat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               UMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               MatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               UMat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               UMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               UMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               UMat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               UMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               GpuMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               UMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               UMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               UMat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               GpuMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               MatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               MatVector corners,
                                                               @ByVal
                                                               GpuMat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               GpuMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               UMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               UMatVector corners,
                                                               @ByVal
                                                               GpuMat ids)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               GpuMat ids,
                                                               @opencv_core.Ptr
                                                               DetectorParameters parameters,
                                                               @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                               GpuMatVector rejectedImgPoints,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat cameraMatrix,
                                                               @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                               GpuMat distCoeff)

detectMarkers

@Namespace(value="cv::aruco")
public static void detectMarkers(@ByVal
                                                               GpuMat image,
                                                               @opencv_core.Ptr
                                                               Dictionary dictionary,
                                                               @ByVal
                                                               GpuMatVector corners,
                                                               @ByVal
                                                               GpuMat ids)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           Mat _objPoints)

\brief Pose estimation for single markers

Parameters:: corners - vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.; markerLength - the length of the markers' side. The returning translation vectors will be in the same unit. Normally, unit is meters.; cameraMatrix - input 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}; distCoeffs - 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; rvecs - array of output rotation vectors (@see Rodrigues) (e.g. std::vector). Each element in rvecs corresponds to the specific marker in imgPoints.; tvecs - array of output translation vectors (e.g. std::vector). Each element in tvecs corresponds to the specific marker in imgPoints.; _objPoints - array of object points of all the marker corners This function receives the detected markers and returns their pose estimation respect to the camera individually. So for each marker, one rotation and translation vector is returned. The returned transformation is the one that transforms points from each marker coordinate system to the camera coordinate system. The marker corrdinate system is centered on the middle of the marker, with the Z axis perpendicular to the marker plane. The coordinates of the four corners of the marker in its own coordinate system are: (-markerLength/2, markerLength/2, 0), (markerLength/2, markerLength/2, 0), (markerLength/2, -markerLength/2, 0), (-markerLength/2, -markerLength/2, 0)
See Also:: detectMarkers

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           Mat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           Mat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           Mat cameraMatrix,
                                                                           @ByVal
                                                                           Mat distCoeffs,
                                                                           @ByVal
                                                                           Mat rvecs,
                                                                           @ByVal
                                                                           Mat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           UMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           UMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           UMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           UMat cameraMatrix,
                                                                           @ByVal
                                                                           UMat distCoeffs,
                                                                           @ByVal
                                                                           UMat rvecs,
                                                                           @ByVal
                                                                           UMat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           GpuMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           MatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           GpuMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           UMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs,
                                                                           @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                           GpuMat _objPoints)

estimatePoseSingleMarkers

@Namespace(value="cv::aruco")
public static void estimatePoseSingleMarkers(@ByVal
                                                                           GpuMatVector corners,
                                                                           float markerLength,
                                                                           @ByVal
                                                                           GpuMat cameraMatrix,
                                                                           @ByVal
                                                                           GpuMat distCoeffs,
                                                                           @ByVal
                                                                           GpuMat rvecs,
                                                                           @ByVal
                                                                           GpuMat tvecs)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

\brief Pose estimation for a board of markers

Parameters:: corners - vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.; ids - list of identifiers for each marker in corners; board - layout of markers in the board. The layout is composed by the marker identifiers and the positions of each marker corner in the board reference system.; cameraMatrix - input 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}; distCoeffs - 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; rvec - Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board (see cv::Rodrigues). Used as initial guess if not empty.; tvec - Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.; useExtrinsicGuess - defines whether initial guess for \b rvec and \b tvec will be used or not. Used as initial guess if not empty. This function receives the detected markers and returns the pose of a marker board composed by those markers. A Board of marker has a single world coordinate system which is defined by the board layout. The returned transformation is the one that transforms points from the board coordinate system to the camera coordinate system. Input markers that are not included in the board layout are ignored. The function returns the number of markers from the input employed for the board pose estimation. Note that returning a 0 means the pose has not been estimated.

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  Mat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  Mat cameraMatrix,
                                                                  @ByVal
                                                                  Mat distCoeffs,
                                                                  @ByVal
                                                                  Mat rvec,
                                                                  @ByVal
                                                                  Mat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  UMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  UMat cameraMatrix,
                                                                  @ByVal
                                                                  UMat distCoeffs,
                                                                  @ByVal
                                                                  UMat rvec,
                                                                  @ByVal
                                                                  UMat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  MatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  UMatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec,
                                                                  @Cast(value="bool")
                                                                  boolean useExtrinsicGuess)

estimatePoseBoard

@Namespace(value="cv::aruco")
public static int estimatePoseBoard(@ByVal
                                                                  GpuMatVector corners,
                                                                  @ByVal
                                                                  GpuMat ids,
                                                                  @opencv_core.Ptr
                                                                  Board board,
                                                                  @ByVal
                                                                  GpuMat cameraMatrix,
                                                                  @ByVal
                                                                  GpuMat distCoeffs,
                                                                  @ByVal
                                                                  GpuMat rvec,
                                                                  @ByVal
                                                                  GpuMat tvec)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       Mat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

\brief Refind 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; minRepDistance - minimum distance between the corners of the rejected candidate and the reprojected marker in order to consider it as a correspondence.; errorCorrectionRate - rate of allowed erroneous bits respect to the error correction capability of the used dictionary. -1 ignores the error correction step.; checkAllOrders - Consider the four posible corner orders in the rejectedCorners array. If it set to false, only the provided corner order is considered (default true).; recoveredIdxs - Optional array to returns the indexes of the recovered candidates in the original rejectedCorners array.; parameters - marker detection parameters This function tries to find markers that were not detected in the basic detecMarkers function. First, based on the current detected marker and the board layout, the function interpolates the position of the missing markers. Then it tries to find correspondence between the reprojected markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters. If camera parameters and distortion coefficients are provided, missing markers are reprojected using projectPoint function. If not, missing marker projections are interpolated using global homography, and all the marker corners in the board must have the same Z coordinate.

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       Mat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       Mat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       Mat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       Mat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       Mat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       UMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       UMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       UMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       UMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       UMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       UMat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       GpuMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       MatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       MatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       GpuMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       UMatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       UMatVector rejectedCorners)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat cameraMatrix,
                                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                       GpuMat distCoeffs,
                                                                       float minRepDistance,
                                                                       float errorCorrectionRate,
                                                                       @Cast(value="bool")
                                                                       boolean checkAllOrders,
                                                                       @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                       GpuMat recoveredIdxs,
                                                                       @opencv_core.Ptr
                                                                       DetectorParameters parameters)

refineDetectedMarkers

@Namespace(value="cv::aruco")
public static void refineDetectedMarkers(@ByVal
                                                                       GpuMat image,
                                                                       @opencv_core.Ptr
                                                                       Board board,
                                                                       @ByVal
                                                                       GpuMatVector detectedCorners,
                                                                       @ByVal
                                                                       GpuMat detectedIds,
                                                                       @ByVal
                                                                       GpuMatVector rejectedCorners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     MatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     Mat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

\brief Draw detected markers in image

Parameters:: image - input/output image. It must have 1 or 3 channels. The number of channels is not altered.; corners - positions of marker corners on input image. (e.g std::vector > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.; ids - vector of identifiers for markers in markersCorners . Optional, if not provided, ids are not painted.; borderColor - color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one to improve visualization. Given an array of detected marker corners and its corresponding ids, this functions draws the markers in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     MatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     UMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     Mat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     UMatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     GpuMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     Mat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     GpuMatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     MatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     UMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     MatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     UMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     UMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     UMatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     GpuMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     UMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     GpuMatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     MatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     GpuMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     MatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     UMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     GpuMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     UMatVector corners)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     GpuMatVector corners,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     GpuMat ids,
                                                                     @ByVal(nullValue="cv::Scalar(0, 255, 0)")
                                                                     Scalar borderColor)

drawDetectedMarkers

@Namespace(value="cv::aruco")
public static void drawDetectedMarkers(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     GpuMatVector corners)

drawAxis

@Namespace(value="cv::aruco")
public static void drawAxis(@ByVal
                                                          Mat image,
                                                          @ByVal
                                                          Mat cameraMatrix,
                                                          @ByVal
                                                          Mat distCoeffs,
                                                          @ByVal
                                                          Mat rvec,
                                                          @ByVal
                                                          Mat tvec,
                                                          float length)

Deprecated. use cv::drawFrameAxes

\brief Draw coordinate system axis from pose estimation

Parameters:: image - input/output image. It must have 1 or 3 channels. The number of channels is not altered.; cameraMatrix - input 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}; distCoeffs - 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; rvec - rotation vector of the coordinate system that will be drawn. (@see Rodrigues).; tvec - translation vector of the coordinate system that will be drawn.; 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.

drawAxis

@Namespace(value="cv::aruco")
public static void drawAxis(@ByVal
                                                          UMat image,
                                                          @ByVal
                                                          UMat cameraMatrix,
                                                          @ByVal
                                                          UMat distCoeffs,
                                                          @ByVal
                                                          UMat rvec,
                                                          @ByVal
                                                          UMat tvec,
                                                          float length)

drawAxis

@Namespace(value="cv::aruco")
public static void drawAxis(@ByVal
                                                          GpuMat image,
                                                          @ByVal
                                                          GpuMat cameraMatrix,
                                                          @ByVal
                                                          GpuMat distCoeffs,
                                                          @ByVal
                                                          GpuMat rvec,
                                                          @ByVal
                                                          GpuMat tvec,
                                                          float length)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            Mat img,
                                                            int borderBits)

\brief Draw a canonical marker image

Parameters:: dictionary - dictionary of markers indicating the type of markers; id - identifier of the marker that will be returned. It has to be a valid id in the specified dictionary.; sidePixels - size of the image in pixels; img - output image with the marker; borderBits - width of the marker border. This function returns a marker image in its canonical form (i.e. ready to be printed)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            Mat img)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            UMat img,
                                                            int borderBits)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            UMat img)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            GpuMat img,
                                                            int borderBits)

drawMarker

@Namespace(value="cv::aruco")
public static void drawMarker(@opencv_core.Ptr
                                                            Dictionary dictionary,
                                                            int id,
                                                            int sidePixels,
                                                            @ByVal
                                                            GpuMat img)

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 Mat img,
                                                                 int marginSize,
                                                                 int borderBits)

\brief Draw a planar board

Parameters:: board - layout of the board that will be drawn. The board should be planar, z coordinate is ignored; outSize - size of the output image in pixels.; img - output image with the board. The size of this image will be outSize and the board will be on the center, keeping the board proportions.; marginSize - minimum margins (in pixels) of the board in the output image; borderBits - width of the marker borders. This function return the image of a planar board, ready to be printed. It assumes the Board layout specified is planar by ignoring the z coordinates of the object points.
See Also:: _drawPlanarBoardImpl

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 Mat img)

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 UMat img,
                                                                 int marginSize,
                                                                 int borderBits)

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 UMat img)

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 GpuMat img,
                                                                 int marginSize,
                                                                 int borderBits)

drawPlanarBoard

@Namespace(value="cv::aruco")
public static void drawPlanarBoard(@opencv_core.Ptr
                                                                 Board board,
                                                                 @ByVal
                                                                 Size outSize,
                                                                 @ByVal
                                                                 GpuMat img)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

\brief Calibrate a camera using aruco markers

Parameters:: corners - vector of detected marker corners in all frames. The corners should have the same format returned by detectMarkers (see #detectMarkers).; ids - list of identifiers for each marker in corners; counter - number of markers in each frame so that corners and ids can be split; board - Marker Board layout; imageSize - Size of the image used only to initialize the intrinsic camera matrix.; cameraMatrix - Output 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} . 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.; distCoeffs - Output 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; rvecs - Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector>). 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).; tvecs - Output vector of translation vectors estimated for each pattern view.; stdDeviationsIntrinsics - Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: (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) If one of parameters is not estimated, it's deviation is equals to zero.; stdDeviationsExtrinsics - Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: (R_1, T_1, \dotsc , R_M, T_M) where M is number of pattern views, R_i, T_i are concatenated 1x3 vectors.; perViewErrors - Output vector of average re-projection errors estimated for each pattern view.; flags - flags Different flags for the calibration process (see #calibrateCamera for details).; 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.

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     Mat ids,
                                                                                                                     @ByVal
                                                                                                                     Mat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     Mat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     Mat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     Mat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     UMat ids,
                                                                                                                     @ByVal
                                                                                                                     UMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     UMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     UMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     UMat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     MatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     MatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     MatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     UMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     UMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors,
                                                                                                                     int flags,
                                                                                                                     @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                     TermCriteria criteria)

calibrateCameraArucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraAruco")
public static double calibrateCameraArucoExtended(@ByVal
                                                                                                                     GpuMatVector corners,
                                                                                                                     @ByVal
                                                                                                                     GpuMat ids,
                                                                                                                     @ByVal
                                                                                                                     GpuMat counter,
                                                                                                                     @opencv_core.Ptr
                                                                                                                     Board board,
                                                                                                                     @ByVal
                                                                                                                     Size imageSize,
                                                                                                                     @ByVal
                                                                                                                     GpuMat cameraMatrix,
                                                                                                                     @ByVal
                                                                                                                     GpuMat distCoeffs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector rvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMatVector tvecs,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsIntrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat stdDeviationsExtrinsics,
                                                                                                                     @ByVal
                                                                                                                     GpuMat perViewErrors)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

\brief It's the same function as #calibrateCameraAruco but without calibration error estimation.

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        Mat ids,
                                                                        @ByVal
                                                                        Mat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        Mat cameraMatrix,
                                                                        @ByVal
                                                                        Mat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        UMat ids,
                                                                        @ByVal
                                                                        UMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        UMat cameraMatrix,
                                                                        @ByVal
                                                                        UMat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        MatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        MatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        UMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        UMatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector rvecs,
                                                                        @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                        GpuMatVector tvecs,
                                                                        int flags,
                                                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                        TermCriteria criteria)

calibrateCameraAruco

@Namespace(value="cv::aruco")
public static double calibrateCameraAruco(@ByVal
                                                                        GpuMatVector corners,
                                                                        @ByVal
                                                                        GpuMat ids,
                                                                        @ByVal
                                                                        GpuMat counter,
                                                                        @opencv_core.Ptr
                                                                        Board board,
                                                                        @ByVal
                                                                        Size imageSize,
                                                                        @ByVal
                                                                        GpuMat cameraMatrix,
                                                                        @ByVal
                                                                        GpuMat distCoeffs)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              MatVector detectedCorners,
                                                                              @ByVal
                                                                              Mat detectedIds,
                                                                              @ByVal
                                                                              Mat objPoints,
                                                                              @ByVal
                                                                              Mat imgPoints)

\brief Given a board configuration and a set of detected markers, returns the corresponding image points and object points to call solvePnP

Parameters:: board - Marker board layout.; detectedCorners - List of detected marker corners of the board.; detectedIds - List of identifiers for each marker.; objPoints - Vector of vectors of board marker points in the board coordinate space.; imgPoints - Vector of vectors of the projections of board marker corner points.

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              UMatVector detectedCorners,
                                                                              @ByVal
                                                                              Mat detectedIds,
                                                                              @ByVal
                                                                              Mat objPoints,
                                                                              @ByVal
                                                                              Mat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              GpuMatVector detectedCorners,
                                                                              @ByVal
                                                                              Mat detectedIds,
                                                                              @ByVal
                                                                              Mat objPoints,
                                                                              @ByVal
                                                                              Mat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              MatVector detectedCorners,
                                                                              @ByVal
                                                                              UMat detectedIds,
                                                                              @ByVal
                                                                              UMat objPoints,
                                                                              @ByVal
                                                                              UMat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              UMatVector detectedCorners,
                                                                              @ByVal
                                                                              UMat detectedIds,
                                                                              @ByVal
                                                                              UMat objPoints,
                                                                              @ByVal
                                                                              UMat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              GpuMatVector detectedCorners,
                                                                              @ByVal
                                                                              UMat detectedIds,
                                                                              @ByVal
                                                                              UMat objPoints,
                                                                              @ByVal
                                                                              UMat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              MatVector detectedCorners,
                                                                              @ByVal
                                                                              GpuMat detectedIds,
                                                                              @ByVal
                                                                              GpuMat objPoints,
                                                                              @ByVal
                                                                              GpuMat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              UMatVector detectedCorners,
                                                                              @ByVal
                                                                              GpuMat detectedIds,
                                                                              @ByVal
                                                                              GpuMat objPoints,
                                                                              @ByVal
                                                                              GpuMat imgPoints)

getBoardObjectAndImagePoints

@Namespace(value="cv::aruco")
public static void getBoardObjectAndImagePoints(@opencv_core.Ptr
                                                                              Board board,
                                                                              @ByVal
                                                                              GpuMatVector detectedCorners,
                                                                              @ByVal
                                                                              GpuMat detectedIds,
                                                                              @ByVal
                                                                              GpuMat objPoints,
                                                                              @ByVal
                                                                              GpuMat imgPoints)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat distCoeffs,
                                                                          int minMarkers)

\brief Interpolate position of ChArUco board corners

Parameters:: markerCorners - vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.; markerIds - list of identifiers for each marker in corners; image - input image necesary for corner refinement. Note that markers are not detected and should be sent in corners and ids parameters.; board - layout of ChArUco board.; charucoCorners - interpolated chessboard corners; charucoIds - interpolated chessboard corners identifiers; cameraMatrix - optional 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; 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.

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          Mat markerIds,
                                                                          @ByVal
                                                                          Mat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Mat charucoCorners,
                                                                          @ByVal
                                                                          Mat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          UMat markerIds,
                                                                          @ByVal
                                                                          UMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          UMat charucoCorners,
                                                                          @ByVal
                                                                          UMat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          MatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          UMatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat distCoeffs,
                                                                          int minMarkers)

interpolateCornersCharuco

@Namespace(value="cv::aruco")
public static int interpolateCornersCharuco(@ByVal
                                                                          GpuMatVector markerCorners,
                                                                          @ByVal
                                                                          GpuMat markerIds,
                                                                          @ByVal
                                                                          GpuMat image,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          GpuMat charucoCorners,
                                                                          @ByVal
                                                                          GpuMat charucoIds)

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  Mat charucoCorners,
                                                                                                  @ByVal
                                                                                                  Mat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  Mat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  Mat distCoeffs,
                                                                                                  @ByVal
                                                                                                  Mat rvec,
                                                                                                  @ByVal
                                                                                                  Mat tvec,
                                                                                                  @Cast(value="bool")
                                                                                                  boolean useExtrinsicGuess)

\brief Pose estimation for a ChArUco board given some of their corners

Parameters:: charucoCorners - vector of detected charuco corners; charucoIds - list of identifiers for each corner in charucoCorners; board - layout of ChArUco board.; cameraMatrix - input 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}; distCoeffs - 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; rvec - Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board (see cv::Rodrigues).; tvec - Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.; 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.

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  Mat charucoCorners,
                                                                                                  @ByVal
                                                                                                  Mat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  Mat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  Mat distCoeffs,
                                                                                                  @ByVal
                                                                                                  Mat rvec,
                                                                                                  @ByVal
                                                                                                  Mat tvec)

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  UMat charucoCorners,
                                                                                                  @ByVal
                                                                                                  UMat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  UMat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  UMat distCoeffs,
                                                                                                  @ByVal
                                                                                                  UMat rvec,
                                                                                                  @ByVal
                                                                                                  UMat tvec,
                                                                                                  @Cast(value="bool")
                                                                                                  boolean useExtrinsicGuess)

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  UMat charucoCorners,
                                                                                                  @ByVal
                                                                                                  UMat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  UMat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  UMat distCoeffs,
                                                                                                  @ByVal
                                                                                                  UMat rvec,
                                                                                                  @ByVal
                                                                                                  UMat tvec)

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  GpuMat charucoCorners,
                                                                                                  @ByVal
                                                                                                  GpuMat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  GpuMat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  GpuMat distCoeffs,
                                                                                                  @ByVal
                                                                                                  GpuMat rvec,
                                                                                                  @ByVal
                                                                                                  GpuMat tvec,
                                                                                                  @Cast(value="bool")
                                                                                                  boolean useExtrinsicGuess)

estimatePoseCharucoBoard

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean estimatePoseCharucoBoard(@ByVal
                                                                                                  GpuMat charucoCorners,
                                                                                                  @ByVal
                                                                                                  GpuMat charucoIds,
                                                                                                  @opencv_core.Ptr
                                                                                                  CharucoBoard board,
                                                                                                  @ByVal
                                                                                                  GpuMat cameraMatrix,
                                                                                                  @ByVal
                                                                                                  GpuMat distCoeffs,
                                                                                                  @ByVal
                                                                                                  GpuMat rvec,
                                                                                                  @ByVal
                                                                                                  GpuMat tvec)

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            Mat image,
                                                                            @ByVal
                                                                            Mat charucoCorners,
                                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                            Mat charucoIds,
                                                                            @ByVal(nullValue="cv::Scalar(255, 0, 0)")
                                                                            Scalar cornerColor)

\brief Draws a set of Charuco corners

Parameters:: image - input/output image. It must have 1 or 3 channels. The number of channels is not altered.; charucoCorners - vector of detected charuco corners; charucoIds - list of identifiers for each corner in charucoCorners; cornerColor - color of the square surrounding each corner This function draws a set of detected Charuco corners. If identifiers vector is provided, it also draws the id of each corner.

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            Mat image,
                                                                            @ByVal
                                                                            Mat charucoCorners)

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            UMat image,
                                                                            @ByVal
                                                                            UMat charucoCorners,
                                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                            UMat charucoIds,
                                                                            @ByVal(nullValue="cv::Scalar(255, 0, 0)")
                                                                            Scalar cornerColor)

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            UMat image,
                                                                            @ByVal
                                                                            UMat charucoCorners)

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            GpuMat image,
                                                                            @ByVal
                                                                            GpuMat charucoCorners,
                                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                            GpuMat charucoIds,
                                                                            @ByVal(nullValue="cv::Scalar(255, 0, 0)")
                                                                            Scalar cornerColor)

drawDetectedCornersCharuco

@Namespace(value="cv::aruco")
public static void drawDetectedCornersCharuco(@ByVal
                                                                            GpuMat image,
                                                                            @ByVal
                                                                            GpuMat charucoCorners)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

\brief Calibrate a camera using Charuco corners

Parameters:: charucoCorners - vector of detected charuco corners per frame; charucoIds - list of identifiers for each corner in charucoCorners per frame; board - Marker Board layout; imageSize - input image size; cameraMatrix - Output 3x3 floating-point camera matrix A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} . 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.; distCoeffs - Output 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; rvecs - Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector>). 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).; tvecs - Output vector of translation vectors estimated for each pattern view.; stdDeviationsIntrinsics - Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: (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) If one of parameters is not estimated, it's deviation is equals to zero.; stdDeviationsExtrinsics - Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: (R_1, T_1, \dotsc , R_M, T_M) where M is number of pattern views, R_i, T_i are concatenated 1x3 vectors.; perViewErrors - Output vector of average re-projection errors estimated for each pattern view.; flags - flags Different flags for the calibration process (see #calibrateCamera for details).; 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.

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         Mat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         Mat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         Mat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         UMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         UMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         UMat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         MatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         MatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         MatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         MatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         UMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         UMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         UMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors,
                                                                                                                         int flags,
                                                                                                                         @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                                                                         TermCriteria criteria)

calibrateCameraCharucoExtended

@Namespace(value="cv::aruco")
 @Name(value="calibrateCameraCharuco")
public static double calibrateCameraCharucoExtended(@ByVal
                                                                                                                         GpuMatVector charucoCorners,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector charucoIds,
                                                                                                                         @opencv_core.Ptr
                                                                                                                         CharucoBoard board,
                                                                                                                         @ByVal
                                                                                                                         Size imageSize,
                                                                                                                         @ByVal
                                                                                                                         GpuMat cameraMatrix,
                                                                                                                         @ByVal
                                                                                                                         GpuMat distCoeffs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector rvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMatVector tvecs,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsIntrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat stdDeviationsExtrinsics,
                                                                                                                         @ByVal
                                                                                                                         GpuMat perViewErrors)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

\brief It's the same function as #calibrateCameraCharuco but without calibration error estimation.

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          Mat cameraMatrix,
                                                                          @ByVal
                                                                          Mat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          UMat cameraMatrix,
                                                                          @ByVal
                                                                          UMat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          MatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          MatVector charucoCorners,
                                                                          @ByVal
                                                                          MatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          UMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          UMatVector charucoCorners,
                                                                          @ByVal
                                                                          UMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector rvecs,
                                                                          @ByVal(nullValue="cv::OutputArrayOfArrays(cv::noArray())")
                                                                          GpuMatVector tvecs,
                                                                          int flags,
                                                                          @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, DBL_EPSILON)")
                                                                          TermCriteria criteria)

calibrateCameraCharuco

@Namespace(value="cv::aruco")
public static double calibrateCameraCharuco(@ByVal
                                                                          GpuMatVector charucoCorners,
                                                                          @ByVal
                                                                          GpuMatVector charucoIds,
                                                                          @opencv_core.Ptr
                                                                          CharucoBoard board,
                                                                          @ByVal
                                                                          Size imageSize,
                                                                          @ByVal
                                                                          GpuMat cameraMatrix,
                                                                          @ByVal
                                                                          GpuMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat distCoeffs)

\brief Detect ChArUco Diamond markers

Parameters:: image - input image necessary for corner subpixel.; markerCorners - list of detected marker corners from detectMarkers function.; markerIds - list of marker ids in markerCorners.; squareMarkerLengthRate - rate between square and marker length: squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary.; 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 > ).; 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.; cameraMatrix - Optional camera calibration matrix.; distCoeffs - Optional camera distortion coefficients. This function detects Diamond markers from the previous detected ArUco markers. The diamonds are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters are provided, the diamond search is based on reprojection. If not, diamond search is based on homography. Homography is faster than reprojection but can slightly reduce the detection rate.

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      Mat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      Mat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      UMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      UMat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      MatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      UMatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat cameraMatrix,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat distCoeffs)

detectCharucoDiamond

@Namespace(value="cv::aruco")
public static void detectCharucoDiamond(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      GpuMatVector markerCorners,
                                                                      @ByVal
                                                                      GpuMat markerIds,
                                                                      float squareMarkerLengthRate,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal
                                                                      GpuMat diamondIds)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

\brief Draw a set of detected ChArUco Diamond markers

Parameters:: image - input/output image. It must have 1 or 3 channels. The number of channels is not altered.; diamondCorners - positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.; diamondIds - vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector). Optional, if not provided, ids are not painted.; borderColor - color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one. Given an array of detected diamonds, this functions draws them in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      Mat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      UMat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      MatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      UMatVector diamondCorners)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat diamondIds,
                                                                      @ByVal(nullValue="cv::Scalar(0, 0, 255)")
                                                                      Scalar borderColor)

drawDetectedDiamonds

@Namespace(value="cv::aruco")
public static void drawDetectedDiamonds(@ByVal
                                                                      GpuMat image,
                                                                      @ByVal
                                                                      GpuMatVector diamondCorners)

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    Mat img,
                                                                    int marginSize,
                                                                    int borderBits)

\brief Draw a ChArUco Diamond marker

Parameters:: dictionary - dictionary of markers indicating the type of markers.; ids - list of 4 ids for each ArUco marker in the ChArUco marker.; squareLength - size of the chessboard squares in pixels.; markerLength - size of the markers in pixels.; img - output image with the marker. The size of this image will be 3*squareLength + 2*marginSize,.; marginSize - minimum margins (in pixels) of the marker in the output image; borderBits - width of the marker borders. This function return the image of a ChArUco marker, ready to be printed.

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    Mat img)

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    UMat img,
                                                                    int marginSize,
                                                                    int borderBits)

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    UMat img)

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    GpuMat img,
                                                                    int marginSize,
                                                                    int borderBits)

drawCharucoDiamond

@Namespace(value="cv::aruco")
public static void drawCharucoDiamond(@opencv_core.Ptr
                                                                    Dictionary dictionary,
                                                                    @ByVal @Cast(value="cv::Vec4i*")
                                                                    Scalar4i ids,
                                                                    int squareLength,
                                                                    int markerLength,
                                                                    @ByVal
                                                                    GpuMat img)

Class opencv_aruco

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.presets.opencv_aruco

Methods inherited from class java.lang.Object

Field Detail

DICT_4X4_50

DICT_4X4_100

DICT_4X4_250

DICT_4X4_1000

DICT_5X5_50

DICT_5X5_100

DICT_5X5_250

DICT_5X5_1000

DICT_6X6_50

DICT_6X6_100

DICT_6X6_250

DICT_6X6_1000

DICT_7X7_50

DICT_7X7_100

DICT_7X7_250

DICT_7X7_1000

DICT_ARUCO_ORIGINAL

DICT_APRILTAG_16h5

DICT_APRILTAG_25h9

DICT_APRILTAG_36h10

DICT_APRILTAG_36h11

CORNER_REFINE_NONE

CORNER_REFINE_SUBPIX

CORNER_REFINE_CONTOUR

CORNER_REFINE_APRILTAG

Constructor Detail

opencv_aruco

Method Detail

getPredefinedDictionary

custom_dictionary

custom_dictionary

custom_dictionary_from

custom_dictionary_from

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseSingleMarkers

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard