opencv_aruco (JavaCPP Presets for OpenCV 4.7.0-1.5.9 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 ARUCO_CCW_CENTER
enum cv::aruco::PatternPositionType

static int ARUCO_CW_TOP_LEFT_CORNER
enum cv::aruco::PatternPositionType

Fields
Modifier and Type	Field and Description
`static int`	`ARUCO_CCW_CENTER` enum cv::aruco::PatternPositionType
`static int`	`ARUCO_CW_TOP_LEFT_CORNER` enum cv::aruco::PatternPositionType

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)` \overload \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 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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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, Dictionary dictionary)` Deprecated. Use CharucoDetector::detectDiamonds
`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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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, Dictionary dictionary)`
`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)`
`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)`
`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)`
`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)`
`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)` Deprecated. Use class ArucoDetector::detectMarkers
`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)`
`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)`
`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)`
`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)`
`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`	`drawPlanarBoard(Board board, Size outSize, GpuMat img, int marginSize, int borderBits)`
`static void`	`drawPlanarBoard(Board board, Size outSize, Mat img, int marginSize, int borderBits)` Deprecated. Use Board::generateImage
`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)` Deprecated. Use cv::solvePnP
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)` Deprecated. Use cv::solvePnP
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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, EstimateParameters estimateParameters)`
`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)` Deprecated. Use Board::matchImagePoints
`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 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)` Deprecated. Use CharucoDetector::detectBoard
`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)` Deprecated. Use class ArucoDetector::refineDetectedMarkers
`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)`
`static boolean`	`testCharucoCornersCollinear(CharucoBoard board, GpuMat charucoIds)`
`static boolean`	`testCharucoCornersCollinear(CharucoBoard board, Mat charucoIds)` Deprecated. Use CharucoBoard::checkCharucoCornersCollinear
`static boolean`	`testCharucoCornersCollinear(CharucoBoard board, UMat charucoIds)`

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
- ARUCO_CCW_CENTER
```
public static final int ARUCO_CCW_CENTER
```
  enum cv::aruco::PatternPositionType
  
  See Also:
  
  Constant Field Values
- ARUCO_CW_TOP_LEFT_CORNER
```
public static final int ARUCO_CW_TOP_LEFT_CORNER
```
  enum cv::aruco::PatternPositionType
  
  See Also:
  
  Constant Field Values

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

Method Detail

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)

Deprecated. Use class ArucoDetector::detectMarkers

\addtogroup aruco /** \{

/** \brief detect markers

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)

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)

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)

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)

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)

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)

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)

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)

detectMarkers

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

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)

Deprecated. Use class ArucoDetector::refineDetectedMarkers

\brief refine detected markers

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)

drawPlanarBoard

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

Deprecated. Use Board::generateImage

\brief draw planar board

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
                                                                  GpuMat img,
                                                                  int marginSize,
                                                                  int borderBits)

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)

Deprecated. Use Board::matchImagePoints

\brief get board object and image 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)

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)

Deprecated. Use cv::solvePnP

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)

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.
See Also:: cv::drawFrameAxes to get world coordinate system axis for object points

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)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

Deprecated. Use cv::solvePnP

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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,
                                                                            @opencv_core.Ptr
                                                                            EstimateParameters estimateParameters)

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)

testCharucoCornersCollinear

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean testCharucoCornersCollinear(@opencv_core.Ptr
                                                                                                       CharucoBoard board,
                                                                                                       @ByVal
                                                                                                       Mat charucoIds)

Deprecated. Use CharucoBoard::checkCharucoCornersCollinear

testCharucoCornersCollinear

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean testCharucoCornersCollinear(@opencv_core.Ptr
                                                                                                       CharucoBoard board,
                                                                                                       @ByVal
                                                                                                       UMat charucoIds)

testCharucoCornersCollinear

@Namespace(value="cv::aruco")
 @Cast(value="bool")
public static boolean testCharucoCornersCollinear(@opencv_core.Ptr
                                                                                                       CharucoBoard board,
                                                                                                       @ByVal
                                                                                                       GpuMat charucoIds)

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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                                                                       @Const @ByRef(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,
                                                                         @Const @ByRef(nullValue="cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS,30, DBL_EPSILON)")
                                                                         TermCriteria criteria)

\overload \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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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,
                                                                         @Const @ByRef(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)

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,
                                                                                                                           @Const @ByRef(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,
                                                                                                                           @Const @ByRef(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

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

ARUCO_CCW_CENTER

ARUCO_CW_TOP_LEFT_CORNER

Constructor Detail

opencv_aruco

Method Detail

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

detectMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

refineDetectedMarkers

drawPlanarBoard

drawPlanarBoard

drawPlanarBoard

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

getBoardObjectAndImagePoints

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseBoard

estimatePoseCharucoBoard

estimatePoseCharucoBoard