View Source Evision.ArUco (Evision v0.2.9)
Summary
Functions
It's the same function as #calibrateCameraAruco but without calibration error estimation.
It's the same function as #calibrateCameraAruco but without calibration error estimation.
Calibrate a camera using aruco markers
Calibrate a camera using aruco markers
It's the same function as #calibrateCameraCharuco but without calibration error estimation.
It's the same function as #calibrateCameraCharuco but without calibration error estimation.
Calibrate a camera using Charuco corners
Calibrate a camera using Charuco corners
Detect ChArUco Diamond markers
Detect ChArUco Diamond markers
detect markers
detect markers
Draw a ChArUco Diamond marker
Draw a ChArUco Diamond marker
Draws a set of Charuco corners
Draws a set of Charuco corners
Draw a set of detected ChArUco Diamond markers
Draw a set of detected ChArUco Diamond markers
Draw detected markers in image
Draw detected markers in image
draw planar board
draw planar board
estimatePoseBoard
Pose estimation for a ChArUco board given some of their corners
Pose estimation for a ChArUco board given some of their corners
estimatePoseSingleMarkers
estimatePoseSingleMarkers
Extend base dictionary by new nMarkers
Extend base dictionary by new nMarkers
Generate a canonical marker image
Generate a canonical marker image
get board object and image points
get board object and image points
Returns one of the predefined dictionaries referenced by DICT_*.
Interpolate position of ChArUco board corners
Interpolate position of ChArUco board corners
refine detected markers
refine detected markers
testCharucoCornersCollinear
Types
@type t() :: %Evision.ArUco{ref: reference()}
Type that represents an ArUco
struct.
ref.
reference()
The underlying erlang resource variable.
Functions
calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs)
View Source@spec calibrateCameraAruco( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()]} | {:error, String.t()}
It's the same function as #calibrateCameraAruco but without calibration error estimation.
Positional Arguments
- corners:
[Evision.Mat]
- ids:
Evision.Mat
- counter:
Evision.Mat
- board:
Board
- imageSize:
Size
Keyword Arguments
- flags:
integer()
. - criteria:
TermCriteria
.
Return
- retval:
double
- cameraMatrix:
Evision.Mat.t()
- distCoeffs:
Evision.Mat.t()
- rvecs:
[Evision.Mat]
. - tvecs:
[Evision.Mat]
.
Has overloading in C++
@deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, opts)
View Source@spec calibrateCameraAruco( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [criteria: term(), flags: term()] | nil ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()]} | {:error, String.t()}
It's the same function as #calibrateCameraAruco but without calibration error estimation.
Positional Arguments
- corners:
[Evision.Mat]
- ids:
Evision.Mat
- counter:
Evision.Mat
- board:
Board
- imageSize:
Size
Keyword Arguments
- flags:
integer()
. - criteria:
TermCriteria
.
Return
- retval:
double
- cameraMatrix:
Evision.Mat.t()
- distCoeffs:
Evision.Mat.t()
- rvecs:
[Evision.Mat]
. - tvecs:
[Evision.Mat]
.
Has overloading in C++
@deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs)
View Source@spec calibrateCameraArucoExtended( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Calibrate a camera using aruco markers
Positional Arguments
corners:
[Evision.Mat]
.vector of detected marker corners in all frames. The corners should have the same format returned by detectMarkers (see #detectMarkers).
ids:
Evision.Mat
.list of identifiers for each marker in corners
counter:
Evision.Mat
.number of markers in each frame so that corners and ids can be split
board:
Board
.Marker Board layout
imageSize:
Size
.Size of the image used only to initialize the intrinsic camera matrix.
Keyword Arguments
flags:
integer()
.flags Different flags for the calibration process (see #calibrateCamera for details).
criteria:
TermCriteria
.Termination criteria for the iterative optimization algorithm.
Return
retval:
double
cameraMatrix:
Evision.Mat.t()
.Output 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
distCoeffs:
Evision.Mat.t()
.Output vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
rvecs:
[Evision.Mat]
.Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the board pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the board pattern in the k-th pattern view (k=0.. M -1).
tvecs:
[Evision.Mat]
.Output vector of translation vectors estimated for each pattern view.
stdDeviationsIntrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
stdDeviationsExtrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views, \f$R_i, T_i\f$ are concatenated 1x3 vectors.
perViewErrors:
Evision.Mat.t()
.Output vector of average re-projection errors estimated for each pattern view.
This function calibrates a camera using an Aruco Board. The function receives a list of detected markers from several views of the Board. The process is similar to the chessboard calibration in calibrateCamera(). The function returns the final re-projection error. @deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors
calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, opts)
View Source@spec calibrateCameraArucoExtended( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [criteria: term(), flags: term()] | nil ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Calibrate a camera using aruco markers
Positional Arguments
corners:
[Evision.Mat]
.vector of detected marker corners in all frames. The corners should have the same format returned by detectMarkers (see #detectMarkers).
ids:
Evision.Mat
.list of identifiers for each marker in corners
counter:
Evision.Mat
.number of markers in each frame so that corners and ids can be split
board:
Board
.Marker Board layout
imageSize:
Size
.Size of the image used only to initialize the intrinsic camera matrix.
Keyword Arguments
flags:
integer()
.flags Different flags for the calibration process (see #calibrateCamera for details).
criteria:
TermCriteria
.Termination criteria for the iterative optimization algorithm.
Return
retval:
double
cameraMatrix:
Evision.Mat.t()
.Output 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
distCoeffs:
Evision.Mat.t()
.Output vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
rvecs:
[Evision.Mat]
.Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the board pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the board pattern in the k-th pattern view (k=0.. M -1).
tvecs:
[Evision.Mat]
.Output vector of translation vectors estimated for each pattern view.
stdDeviationsIntrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
stdDeviationsExtrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views, \f$R_i, T_i\f$ are concatenated 1x3 vectors.
perViewErrors:
Evision.Mat.t()
.Output vector of average re-projection errors estimated for each pattern view.
This function calibrates a camera using an Aruco Board. The function receives a list of detected markers from several views of the Board. The process is similar to the chessboard calibration in calibrateCamera(). The function returns the final re-projection error. @deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors
calibrateCameraCharuco(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs)
View Source@spec calibrateCameraCharuco( [Evision.Mat.maybe_mat_in()], [Evision.Mat.maybe_mat_in()], Evision.ArUco.CharucoBoard.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()]} | {:error, String.t()}
It's the same function as #calibrateCameraCharuco but without calibration error estimation.
Positional Arguments
- charucoCorners:
[Evision.Mat]
- charucoIds:
[Evision.Mat]
- board:
Evision.ArUco.CharucoBoard
- imageSize:
Size
Keyword Arguments
- flags:
integer()
. - criteria:
TermCriteria
.
Return
- retval:
double
- cameraMatrix:
Evision.Mat.t()
- distCoeffs:
Evision.Mat.t()
- rvecs:
[Evision.Mat]
. - tvecs:
[Evision.Mat]
.
@deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraCharuco(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
calibrateCameraCharuco(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs, opts)
View Source@spec calibrateCameraCharuco( [Evision.Mat.maybe_mat_in()], [Evision.Mat.maybe_mat_in()], Evision.ArUco.CharucoBoard.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [criteria: term(), flags: term()] | nil ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()]} | {:error, String.t()}
It's the same function as #calibrateCameraCharuco but without calibration error estimation.
Positional Arguments
- charucoCorners:
[Evision.Mat]
- charucoIds:
[Evision.Mat]
- board:
Evision.ArUco.CharucoBoard
- imageSize:
Size
Keyword Arguments
- flags:
integer()
. - criteria:
TermCriteria
.
Return
- retval:
double
- cameraMatrix:
Evision.Mat.t()
- distCoeffs:
Evision.Mat.t()
- rvecs:
[Evision.Mat]
. - tvecs:
[Evision.Mat]
.
@deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraCharuco(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
calibrateCameraCharucoExtended(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs)
View Source@spec calibrateCameraCharucoExtended( [Evision.Mat.maybe_mat_in()], [Evision.Mat.maybe_mat_in()], Evision.ArUco.CharucoBoard.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Calibrate a camera using Charuco corners
Positional Arguments
charucoCorners:
[Evision.Mat]
.vector of detected charuco corners per frame
charucoIds:
[Evision.Mat]
.list of identifiers for each corner in charucoCorners per frame
board:
Evision.ArUco.CharucoBoard
.Marker Board layout
imageSize:
Size
.input image size
Keyword Arguments
flags:
integer()
.flags Different flags for the calibration process (see #calibrateCamera for details).
criteria:
TermCriteria
.Termination criteria for the iterative optimization algorithm.
Return
retval:
double
cameraMatrix:
Evision.Mat.t()
.Output 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
distCoeffs:
Evision.Mat.t()
.Output vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
rvecs:
[Evision.Mat]
.Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the board pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the board pattern in the k-th pattern view (k=0.. M -1).
tvecs:
[Evision.Mat]
.Output vector of translation vectors estimated for each pattern view.
stdDeviationsIntrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
stdDeviationsExtrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views, \f$R_i, T_i\f$ are concatenated 1x3 vectors.
perViewErrors:
Evision.Mat.t()
.Output vector of average re-projection errors estimated for each pattern view.
This function calibrates a camera using a set of corners of a Charuco Board. The function receives a list of detected corners and its identifiers from several views of the Board. The function returns the final re-projection error. @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraCharucoExtended(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors
calibrateCameraCharucoExtended(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs, opts)
View Source@spec calibrateCameraCharucoExtended( [Evision.Mat.maybe_mat_in()], [Evision.Mat.maybe_mat_in()], Evision.ArUco.CharucoBoard.t(), {number(), number()}, Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [criteria: term(), flags: term()] | nil ) :: {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()], [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Calibrate a camera using Charuco corners
Positional Arguments
charucoCorners:
[Evision.Mat]
.vector of detected charuco corners per frame
charucoIds:
[Evision.Mat]
.list of identifiers for each corner in charucoCorners per frame
board:
Evision.ArUco.CharucoBoard
.Marker Board layout
imageSize:
Size
.input image size
Keyword Arguments
flags:
integer()
.flags Different flags for the calibration process (see #calibrateCamera for details).
criteria:
TermCriteria
.Termination criteria for the iterative optimization algorithm.
Return
retval:
double
cameraMatrix:
Evision.Mat.t()
.Output 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ . If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
distCoeffs:
Evision.Mat.t()
.Output vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
rvecs:
[Evision.Mat]
.Output vector of rotation vectors (see Rodrigues ) estimated for each board view (e.g. std::vector<cv::Mat>>). That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the board pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the board pattern in the k-th pattern view (k=0.. M -1).
tvecs:
[Evision.Mat]
.Output vector of translation vectors estimated for each pattern view.
stdDeviationsIntrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
stdDeviationsExtrinsics:
Evision.Mat.t()
.Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R_1, T_1, \dotsc , R_M, T_M)\f$ where M is number of pattern views, \f$R_i, T_i\f$ are concatenated 1x3 vectors.
perViewErrors:
Evision.Mat.t()
.Output vector of average re-projection errors estimated for each pattern view.
This function calibrates a camera using a set of corners of a Charuco Board. The function receives a list of detected corners and its identifiers from several views of the Board. The function returns the final re-projection error. @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
calibrateCameraCharucoExtended(charucoCorners, charucoIds, board, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors
detectCharucoDiamond(image, markerCorners, markerIds, squareMarkerLengthRate)
View Source@spec detectCharucoDiamond( Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), number() ) :: {[Evision.Mat.t()], Evision.Mat.t()} | {:error, String.t()}
Detect ChArUco Diamond markers
Positional Arguments
image:
Evision.Mat
.input image necessary for corner subpixel.
markerCorners:
[Evision.Mat]
.list of detected marker corners from detectMarkers function.
markerIds:
Evision.Mat
.list of marker ids in markerCorners.
squareMarkerLengthRate:
float
.rate between square and marker length: squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary.
Keyword Arguments
cameraMatrix:
Evision.Mat
.Optional camera calibration matrix.
distCoeffs:
Evision.Mat
.Optional camera distortion coefficients.
dictionary:
Dictionary
.dictionary of markers indicating the type of markers.
Return
diamondCorners:
[Evision.Mat]
.output list of detected diamond corners (4 corners per diamond). The order is the same than in marker corners: top left, top right, bottom right and bottom left. Similar format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).
diamondIds:
Evision.Mat.t()
.ids of the diamonds in diamondCorners. The id of each diamond is in fact of type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the diamond.
This function detects Diamond markers from the previous detected ArUco markers. The diamonds are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters are provided, the diamond search is based on reprojection. If not, diamond search is based on homography. Homography is faster than reprojection, but less accurate. @deprecated Use CharucoDetector::detectDiamonds
Python prototype (for reference only):
detectCharucoDiamond(image, markerCorners, markerIds, squareMarkerLengthRate[, diamondCorners[, diamondIds[, cameraMatrix[, distCoeffs[, dictionary]]]]]) -> diamondCorners, diamondIds
detectCharucoDiamond(image, markerCorners, markerIds, squareMarkerLengthRate, opts)
View Source@spec detectCharucoDiamond( Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), number(), [cameraMatrix: term(), dictionary: term(), distCoeffs: term()] | nil ) :: {[Evision.Mat.t()], Evision.Mat.t()} | {:error, String.t()}
Detect ChArUco Diamond markers
Positional Arguments
image:
Evision.Mat
.input image necessary for corner subpixel.
markerCorners:
[Evision.Mat]
.list of detected marker corners from detectMarkers function.
markerIds:
Evision.Mat
.list of marker ids in markerCorners.
squareMarkerLengthRate:
float
.rate between square and marker length: squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary.
Keyword Arguments
cameraMatrix:
Evision.Mat
.Optional camera calibration matrix.
distCoeffs:
Evision.Mat
.Optional camera distortion coefficients.
dictionary:
Dictionary
.dictionary of markers indicating the type of markers.
Return
diamondCorners:
[Evision.Mat]
.output list of detected diamond corners (4 corners per diamond). The order is the same than in marker corners: top left, top right, bottom right and bottom left. Similar format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).
diamondIds:
Evision.Mat.t()
.ids of the diamonds in diamondCorners. The id of each diamond is in fact of type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the diamond.
This function detects Diamond markers from the previous detected ArUco markers. The diamonds are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters are provided, the diamond search is based on reprojection. If not, diamond search is based on homography. Homography is faster than reprojection, but less accurate. @deprecated Use CharucoDetector::detectDiamonds
Python prototype (for reference only):
detectCharucoDiamond(image, markerCorners, markerIds, squareMarkerLengthRate[, diamondCorners[, diamondIds[, cameraMatrix[, distCoeffs[, dictionary]]]]]) -> diamondCorners, diamondIds
@spec detectMarkers(Evision.Mat.maybe_mat_in(), Evision.ArUco.Dictionary.t()) :: {[Evision.Mat.t()], Evision.Mat.t(), [Evision.Mat.t()]} | {:error, String.t()}
detect markers
Positional Arguments
- image:
Evision.Mat
- dictionary:
Dictionary
Keyword Arguments
- parameters:
DetectorParameters
.
Return
- corners:
[Evision.Mat]
. - ids:
Evision.Mat.t()
. - rejectedImgPoints:
[Evision.Mat]
.
@deprecated Use class ArucoDetector::detectMarkers
Python prototype (for reference only):
detectMarkers(image, dictionary[, corners[, ids[, parameters[, rejectedImgPoints]]]]) -> corners, ids, rejectedImgPoints
@spec detectMarkers( Evision.Mat.maybe_mat_in(), Evision.ArUco.Dictionary.t(), [{:parameters, term()}] | nil ) :: {[Evision.Mat.t()], Evision.Mat.t(), [Evision.Mat.t()]} | {:error, String.t()}
detect markers
Positional Arguments
- image:
Evision.Mat
- dictionary:
Dictionary
Keyword Arguments
- parameters:
DetectorParameters
.
Return
- corners:
[Evision.Mat]
. - ids:
Evision.Mat.t()
. - rejectedImgPoints:
[Evision.Mat]
.
@deprecated Use class ArucoDetector::detectMarkers
Python prototype (for reference only):
detectMarkers(image, dictionary[, corners[, ids[, parameters[, rejectedImgPoints]]]]) -> corners, ids, rejectedImgPoints
@spec drawCharucoDiamond( Evision.ArUco.Dictionary.t(), {integer(), integer(), integer(), integer()}, integer(), integer() ) :: Evision.Mat.t() | {:error, String.t()}
Draw a ChArUco Diamond marker
Positional Arguments
dictionary:
Dictionary
.dictionary of markers indicating the type of markers.
ids:
Vec4i
.list of 4 ids for each ArUco marker in the ChArUco marker.
squareLength:
integer()
.size of the chessboard squares in pixels.
markerLength:
integer()
.size of the markers in pixels.
Keyword Arguments
marginSize:
integer()
.minimum margins (in pixels) of the marker in the output image
borderBits:
integer()
.width of the marker borders.
Return
img:
Evision.Mat.t()
.output image with the marker. The size of this image will be 3squareLength + 2marginSize,.
This function return the image of a ChArUco marker, ready to be printed. @deprecated Use CharucoBoard::generateImage()
Python prototype (for reference only):
drawCharucoDiamond(dictionary, ids, squareLength, markerLength[, img[, marginSize[, borderBits]]]) -> img
drawCharucoDiamond(dictionary, ids, squareLength, markerLength, opts)
View Source@spec drawCharucoDiamond( Evision.ArUco.Dictionary.t(), {integer(), integer(), integer(), integer()}, integer(), integer(), [borderBits: term(), marginSize: term()] | nil ) :: Evision.Mat.t() | {:error, String.t()}
Draw a ChArUco Diamond marker
Positional Arguments
dictionary:
Dictionary
.dictionary of markers indicating the type of markers.
ids:
Vec4i
.list of 4 ids for each ArUco marker in the ChArUco marker.
squareLength:
integer()
.size of the chessboard squares in pixels.
markerLength:
integer()
.size of the markers in pixels.
Keyword Arguments
marginSize:
integer()
.minimum margins (in pixels) of the marker in the output image
borderBits:
integer()
.width of the marker borders.
Return
img:
Evision.Mat.t()
.output image with the marker. The size of this image will be 3squareLength + 2marginSize,.
This function return the image of a ChArUco marker, ready to be printed. @deprecated Use CharucoBoard::generateImage()
Python prototype (for reference only):
drawCharucoDiamond(dictionary, ids, squareLength, markerLength[, img[, marginSize[, borderBits]]]) -> img
@spec drawDetectedCornersCharuco( Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: Evision.Mat.t() | {:error, String.t()}
Draws a set of Charuco corners
Positional Arguments
charucoCorners:
Evision.Mat
.vector of detected charuco corners
Keyword Arguments
charucoIds:
Evision.Mat
.list of identifiers for each corner in charucoCorners
cornerColor:
Evision.scalar()
.color of the square surrounding each corner
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
This function draws a set of detected Charuco corners. If identifiers vector is provided, it also draws the id of each corner.
Python prototype (for reference only):
drawDetectedCornersCharuco(image, charucoCorners[, charucoIds[, cornerColor]]) -> image
@spec drawDetectedCornersCharuco( Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [charucoIds: term(), cornerColor: term()] | nil ) :: Evision.Mat.t() | {:error, String.t()}
Draws a set of Charuco corners
Positional Arguments
charucoCorners:
Evision.Mat
.vector of detected charuco corners
Keyword Arguments
charucoIds:
Evision.Mat
.list of identifiers for each corner in charucoCorners
cornerColor:
Evision.scalar()
.color of the square surrounding each corner
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
This function draws a set of detected Charuco corners. If identifiers vector is provided, it also draws the id of each corner.
Python prototype (for reference only):
drawDetectedCornersCharuco(image, charucoCorners[, charucoIds[, cornerColor]]) -> image
@spec drawDetectedDiamonds(Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()]) :: Evision.Mat.t() | {:error, String.t()}
Draw a set of detected ChArUco Diamond markers
Positional Arguments
diamondCorners:
[Evision.Mat]
.positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
Keyword Arguments
diamondIds:
Evision.Mat
.vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>). Optional, if not provided, ids are not painted.
borderColor:
Evision.scalar()
.color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one.
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
Given an array of detected diamonds, this functions draws them in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.
Python prototype (for reference only):
drawDetectedDiamonds(image, diamondCorners[, diamondIds[, borderColor]]) -> image
@spec drawDetectedDiamonds( Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()], [borderColor: term(), diamondIds: term()] | nil ) :: Evision.Mat.t() | {:error, String.t()}
Draw a set of detected ChArUco Diamond markers
Positional Arguments
diamondCorners:
[Evision.Mat]
.positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
Keyword Arguments
diamondIds:
Evision.Mat
.vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>). Optional, if not provided, ids are not painted.
borderColor:
Evision.scalar()
.color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one.
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
Given an array of detected diamonds, this functions draws them in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.
Python prototype (for reference only):
drawDetectedDiamonds(image, diamondCorners[, diamondIds[, borderColor]]) -> image
@spec drawDetectedMarkers(Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()]) :: Evision.Mat.t() | {:error, String.t()}
Draw detected markers in image
Positional Arguments
corners:
[Evision.Mat]
.positions of marker corners on input image. (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
Keyword Arguments
ids:
Evision.Mat
.vector of identifiers for markers in markersCorners . Optional, if not provided, ids are not painted.
borderColor:
Evision.scalar()
.color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one to improve visualization.
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
Given an array of detected marker corners and its corresponding ids, this functions draws the markers in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.
Python prototype (for reference only):
drawDetectedMarkers(image, corners[, ids[, borderColor]]) -> image
@spec drawDetectedMarkers( Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()], [borderColor: term(), ids: term()] | nil ) :: Evision.Mat.t() | {:error, String.t()}
Draw detected markers in image
Positional Arguments
corners:
[Evision.Mat]
.positions of marker corners on input image. (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
Keyword Arguments
ids:
Evision.Mat
.vector of identifiers for markers in markersCorners . Optional, if not provided, ids are not painted.
borderColor:
Evision.scalar()
.color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one to improve visualization.
Return
image:
Evision.Mat.t()
.input/output image. It must have 1 or 3 channels. The number of channels is not altered.
Given an array of detected marker corners and its corresponding ids, this functions draws the markers in the image. The marker borders are painted and the markers identifiers if provided. Useful for debugging purposes.
Python prototype (for reference only):
drawDetectedMarkers(image, corners[, ids[, borderColor]]) -> image
@spec drawPlanarBoard( Evision.ArUco.Board.t(), {number(), number()}, integer(), integer() ) :: Evision.Mat.t() | {:error, String.t()}
draw planar board
Positional Arguments
- board:
Board
- outSize:
Size
- marginSize:
integer()
- borderBits:
integer()
Return
- img:
Evision.Mat.t()
.
@deprecated Use Board::generateImage
Python prototype (for reference only):
drawPlanarBoard(board, outSize, marginSize, borderBits[, img]) -> img
@spec drawPlanarBoard( Evision.ArUco.Board.t(), {number(), number()}, integer(), integer(), [{atom(), term()}, ...] | nil ) :: Evision.Mat.t() | {:error, String.t()}
draw planar board
Positional Arguments
- board:
Board
- outSize:
Size
- marginSize:
integer()
- borderBits:
integer()
Return
- img:
Evision.Mat.t()
.
@deprecated Use Board::generateImage
Python prototype (for reference only):
drawPlanarBoard(board, outSize, marginSize, borderBits[, img]) -> img
estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec)
View Source@spec estimatePoseBoard( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {integer(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
estimatePoseBoard
Positional Arguments
- corners:
[Evision.Mat]
- ids:
Evision.Mat
- board:
Board
- cameraMatrix:
Evision.Mat
- distCoeffs:
Evision.Mat
Keyword Arguments
- useExtrinsicGuess:
bool
.
Return
- retval:
integer()
- rvec:
Evision.Mat.t()
- tvec:
Evision.Mat.t()
@deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec[, useExtrinsicGuess]) -> retval, rvec, tvec
estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec, opts)
View Source@spec estimatePoseBoard( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{:useExtrinsicGuess, term()}] | nil ) :: {integer(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
estimatePoseBoard
Positional Arguments
- corners:
[Evision.Mat]
- ids:
Evision.Mat
- board:
Board
- cameraMatrix:
Evision.Mat
- distCoeffs:
Evision.Mat
Keyword Arguments
- useExtrinsicGuess:
bool
.
Return
- retval:
integer()
- rvec:
Evision.Mat.t()
- tvec:
Evision.Mat.t()
@deprecated Use Board::matchImagePoints and cv::solvePnP
Python prototype (for reference only):
estimatePoseBoard(corners, ids, board, cameraMatrix, distCoeffs, rvec, tvec[, useExtrinsicGuess]) -> retval, rvec, tvec
estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec)
View Source@spec estimatePoseCharucoBoard( Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.CharucoBoard.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {Evision.Mat.t(), Evision.Mat.t()} | false | {:error, String.t()}
Pose estimation for a ChArUco board given some of their corners
Positional Arguments
charucoCorners:
Evision.Mat
.vector of detected charuco corners
charucoIds:
Evision.Mat
.list of identifiers for each corner in charucoCorners
board:
Evision.ArUco.CharucoBoard
.layout of ChArUco board.
cameraMatrix:
Evision.Mat
.input 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
distCoeffs:
Evision.Mat
.vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
Keyword Arguments
useExtrinsicGuess:
bool
.defines whether initial guess for \b rvec and \b tvec will be used or not.
Return
retval:
bool
rvec:
Evision.Mat.t()
.Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board (see cv::Rodrigues).
tvec:
Evision.Mat.t()
.Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.
This function estimates a Charuco board pose from some detected corners. The function checks if the input corners are enough and valid to perform pose estimation. If pose estimation is valid, returns true, else returns false. @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP @sa use cv::drawFrameAxes to get world coordinate system axis for object points
Python prototype (for reference only):
estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec[, useExtrinsicGuess]) -> retval, rvec, tvec
estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec, opts)
View Source@spec estimatePoseCharucoBoard( Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.CharucoBoard.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{:useExtrinsicGuess, term()}] | nil ) :: {Evision.Mat.t(), Evision.Mat.t()} | false | {:error, String.t()}
Pose estimation for a ChArUco board given some of their corners
Positional Arguments
charucoCorners:
Evision.Mat
.vector of detected charuco corners
charucoIds:
Evision.Mat
.list of identifiers for each corner in charucoCorners
board:
Evision.ArUco.CharucoBoard
.layout of ChArUco board.
cameraMatrix:
Evision.Mat
.input 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
distCoeffs:
Evision.Mat
.vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
Keyword Arguments
useExtrinsicGuess:
bool
.defines whether initial guess for \b rvec and \b tvec will be used or not.
Return
retval:
bool
rvec:
Evision.Mat.t()
.Output vector (e.g. cv::Mat) corresponding to the rotation vector of the board (see cv::Rodrigues).
tvec:
Evision.Mat.t()
.Output vector (e.g. cv::Mat) corresponding to the translation vector of the board.
This function estimates a Charuco board pose from some detected corners. The function checks if the input corners are enough and valid to perform pose estimation. If pose estimation is valid, returns true, else returns false. @deprecated Use CharucoBoard::matchImagePoints and cv::solvePnP @sa use cv::drawFrameAxes to get world coordinate system axis for object points
Python prototype (for reference only):
estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec[, useExtrinsicGuess]) -> retval, rvec, tvec
estimatePoseSingleMarkers(corners, markerLength, cameraMatrix, distCoeffs)
View Source@spec estimatePoseSingleMarkers( [Evision.Mat.maybe_mat_in()], number(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
estimatePoseSingleMarkers
Positional Arguments
- corners:
[Evision.Mat]
- markerLength:
float
- cameraMatrix:
Evision.Mat
- distCoeffs:
Evision.Mat
Keyword Arguments
- estimateParameters:
EstimateParameters
.
Return
- rvecs:
Evision.Mat.t()
. - tvecs:
Evision.Mat.t()
. - objPoints:
Evision.Mat.t()
.
@deprecated Use cv::solvePnP
Python prototype (for reference only):
estimatePoseSingleMarkers(corners, markerLength, cameraMatrix, distCoeffs[, rvecs[, tvecs[, objPoints[, estimateParameters]]]]) -> rvecs, tvecs, objPoints
estimatePoseSingleMarkers(corners, markerLength, cameraMatrix, distCoeffs, opts)
View Source@spec estimatePoseSingleMarkers( [Evision.Mat.maybe_mat_in()], number(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{:estimateParameters, term()}] | nil ) :: {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
estimatePoseSingleMarkers
Positional Arguments
- corners:
[Evision.Mat]
- markerLength:
float
- cameraMatrix:
Evision.Mat
- distCoeffs:
Evision.Mat
Keyword Arguments
- estimateParameters:
EstimateParameters
.
Return
- rvecs:
Evision.Mat.t()
. - tvecs:
Evision.Mat.t()
. - objPoints:
Evision.Mat.t()
.
@deprecated Use cv::solvePnP
Python prototype (for reference only):
estimatePoseSingleMarkers(corners, markerLength, cameraMatrix, distCoeffs[, rvecs[, tvecs[, objPoints[, estimateParameters]]]]) -> rvecs, tvecs, objPoints
@spec extendDictionary(integer(), integer()) :: Evision.ArUco.Dictionary.t() | {:error, String.t()}
Extend base dictionary by new nMarkers
Positional Arguments
nMarkers:
integer()
.number of markers in the dictionary
markerSize:
integer()
.number of bits per dimension of each markers
Keyword Arguments
baseDictionary:
Dictionary
.Include the markers in this dictionary at the beginning (optional)
randomSeed:
integer()
.a user supplied seed for theRNG()
Return
- retval:
Dictionary
This function creates a new dictionary composed by nMarkers markers and each markers composed by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly included and the rest are generated based on them. If the size of baseDictionary is higher than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.
Python prototype (for reference only):
extendDictionary(nMarkers, markerSize[, baseDictionary[, randomSeed]]) -> retval
@spec extendDictionary( integer(), integer(), [baseDictionary: term(), randomSeed: term()] | nil ) :: Evision.ArUco.Dictionary.t() | {:error, String.t()}
Extend base dictionary by new nMarkers
Positional Arguments
nMarkers:
integer()
.number of markers in the dictionary
markerSize:
integer()
.number of bits per dimension of each markers
Keyword Arguments
baseDictionary:
Dictionary
.Include the markers in this dictionary at the beginning (optional)
randomSeed:
integer()
.a user supplied seed for theRNG()
Return
- retval:
Dictionary
This function creates a new dictionary composed by nMarkers markers and each markers composed by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly included and the rest are generated based on them. If the size of baseDictionary is higher than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.
Python prototype (for reference only):
extendDictionary(nMarkers, markerSize[, baseDictionary[, randomSeed]]) -> retval
@spec generateImageMarker(Evision.ArUco.Dictionary.t(), integer(), integer()) :: Evision.Mat.t() | {:error, String.t()}
Generate a canonical marker image
Positional Arguments
dictionary:
Dictionary
.dictionary of markers indicating the type of markers
id:
integer()
.identifier of the marker that will be returned. It has to be a valid id in the specified dictionary.
sidePixels:
integer()
.size of the image in pixels
Keyword Arguments
borderBits:
integer()
.width of the marker border.
Return
img:
Evision.Mat.t()
.output image with the marker
This function returns a marker image in its canonical form (i.e. ready to be printed)
Python prototype (for reference only):
generateImageMarker(dictionary, id, sidePixels[, img[, borderBits]]) -> img
@spec generateImageMarker( Evision.ArUco.Dictionary.t(), integer(), integer(), [{:borderBits, term()}] | nil ) :: Evision.Mat.t() | {:error, String.t()}
Generate a canonical marker image
Positional Arguments
dictionary:
Dictionary
.dictionary of markers indicating the type of markers
id:
integer()
.identifier of the marker that will be returned. It has to be a valid id in the specified dictionary.
sidePixels:
integer()
.size of the image in pixels
Keyword Arguments
borderBits:
integer()
.width of the marker border.
Return
img:
Evision.Mat.t()
.output image with the marker
This function returns a marker image in its canonical form (i.e. ready to be printed)
Python prototype (for reference only):
generateImageMarker(dictionary, id, sidePixels[, img[, borderBits]]) -> img
@spec getBoardObjectAndImagePoints( Evision.ArUco.Board.t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in() ) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
get board object and image points
Positional Arguments
- board:
Board
- detectedCorners:
[Evision.Mat]
- detectedIds:
Evision.Mat
Return
- objPoints:
Evision.Mat.t()
. - imgPoints:
Evision.Mat.t()
.
@deprecated Use Board::matchImagePoints
Python prototype (for reference only):
getBoardObjectAndImagePoints(board, detectedCorners, detectedIds[, objPoints[, imgPoints]]) -> objPoints, imgPoints
getBoardObjectAndImagePoints(board, detectedCorners, detectedIds, opts)
View Source@spec getBoardObjectAndImagePoints( Evision.ArUco.Board.t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
get board object and image points
Positional Arguments
- board:
Board
- detectedCorners:
[Evision.Mat]
- detectedIds:
Evision.Mat
Return
- objPoints:
Evision.Mat.t()
. - imgPoints:
Evision.Mat.t()
.
@deprecated Use Board::matchImagePoints
Python prototype (for reference only):
getBoardObjectAndImagePoints(board, detectedCorners, detectedIds[, objPoints[, imgPoints]]) -> objPoints, imgPoints
@spec getPredefinedDictionary(Keyword.t()) :: any() | {:error, String.t()}
@spec getPredefinedDictionary(integer()) :: Evision.ArUco.Dictionary.t() | {:error, String.t()}
Returns one of the predefined dictionaries referenced by DICT_*.
Positional Arguments
- dict:
integer()
Return
- retval:
Dictionary
Python prototype (for reference only):
getPredefinedDictionary(dict) -> retval
@spec interpolateCornersCharuco( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.CharucoBoard.t() ) :: {integer(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Interpolate position of ChArUco board corners
Positional Arguments
markerCorners:
[Evision.Mat]
.vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
markerIds:
Evision.Mat
.list of identifiers for each marker in corners
image:
Evision.Mat
.input image necesary for corner refinement. Note that markers are not detected and should be sent in corners and ids parameters.
board:
Evision.ArUco.CharucoBoard
.layout of ChArUco board.
Keyword Arguments
cameraMatrix:
Evision.Mat
.optional 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
distCoeffs:
Evision.Mat
.optional vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
minMarkers:
integer()
.number of adjacent markers that must be detected to return a charuco corner
Return
retval:
integer()
charucoCorners:
Evision.Mat.t()
.interpolated chessboard corners
charucoIds:
Evision.Mat.t()
.interpolated chessboard corners identifiers
This function receives the detected markers and returns the 2D position of the chessboard corners from a ChArUco board using the detected Aruco markers. If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography. Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds. The function returns the number of interpolated corners. @deprecated Use CharucoDetector::detectBoard
Python prototype (for reference only):
interpolateCornersCharuco(markerCorners, markerIds, image, board[, charucoCorners[, charucoIds[, cameraMatrix[, distCoeffs[, minMarkers]]]]]) -> retval, charucoCorners, charucoIds
interpolateCornersCharuco(markerCorners, markerIds, image, board, opts)
View Source@spec interpolateCornersCharuco( [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), Evision.ArUco.CharucoBoard.t(), [cameraMatrix: term(), distCoeffs: term(), minMarkers: term()] | nil ) :: {integer(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
Interpolate position of ChArUco board corners
Positional Arguments
markerCorners:
[Evision.Mat]
.vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.
markerIds:
Evision.Mat
.list of identifiers for each marker in corners
image:
Evision.Mat
.input image necesary for corner refinement. Note that markers are not detected and should be sent in corners and ids parameters.
board:
Evision.ArUco.CharucoBoard
.layout of ChArUco board.
Keyword Arguments
cameraMatrix:
Evision.Mat
.optional 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
distCoeffs:
Evision.Mat
.optional vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
minMarkers:
integer()
.number of adjacent markers that must be detected to return a charuco corner
Return
retval:
integer()
charucoCorners:
Evision.Mat.t()
.interpolated chessboard corners
charucoIds:
Evision.Mat.t()
.interpolated chessboard corners identifiers
This function receives the detected markers and returns the 2D position of the chessboard corners from a ChArUco board using the detected Aruco markers. If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography. Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds. The function returns the number of interpolated corners. @deprecated Use CharucoDetector::detectBoard
Python prototype (for reference only):
interpolateCornersCharuco(markerCorners, markerIds, image, board[, charucoCorners[, charucoIds[, cameraMatrix[, distCoeffs[, minMarkers]]]]]) -> retval, charucoCorners, charucoIds
refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners)
View Source@spec refineDetectedMarkers( Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()] ) :: {[Evision.Mat.t()], Evision.Mat.t(), [Evision.Mat.t()], Evision.Mat.t()} | {:error, String.t()}
refine detected markers
Positional Arguments
- image:
Evision.Mat
- board:
Board
Keyword Arguments
- cameraMatrix:
Evision.Mat
. - distCoeffs:
Evision.Mat
. - minRepDistance:
float
. - errorCorrectionRate:
float
. - checkAllOrders:
bool
. - parameters:
DetectorParameters
.
Return
- detectedCorners:
[Evision.Mat]
- detectedIds:
Evision.Mat.t()
- rejectedCorners:
[Evision.Mat]
- recoveredIdxs:
Evision.Mat.t()
.
@deprecated Use class ArucoDetector::refineDetectedMarkers
Python prototype (for reference only):
refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners[, cameraMatrix[, distCoeffs[, minRepDistance[, errorCorrectionRate[, checkAllOrders[, recoveredIdxs[, parameters]]]]]]]) -> detectedCorners, detectedIds, rejectedCorners, recoveredIdxs
refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners, opts)
View Source@spec refineDetectedMarkers( Evision.Mat.maybe_mat_in(), Evision.ArUco.Board.t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in(), [Evision.Mat.maybe_mat_in()], [ cameraMatrix: term(), checkAllOrders: term(), distCoeffs: term(), errorCorrectionRate: term(), minRepDistance: term(), parameters: term() ] | nil ) :: {[Evision.Mat.t()], Evision.Mat.t(), [Evision.Mat.t()], Evision.Mat.t()} | {:error, String.t()}
refine detected markers
Positional Arguments
- image:
Evision.Mat
- board:
Board
Keyword Arguments
- cameraMatrix:
Evision.Mat
. - distCoeffs:
Evision.Mat
. - minRepDistance:
float
. - errorCorrectionRate:
float
. - checkAllOrders:
bool
. - parameters:
DetectorParameters
.
Return
- detectedCorners:
[Evision.Mat]
- detectedIds:
Evision.Mat.t()
- rejectedCorners:
[Evision.Mat]
- recoveredIdxs:
Evision.Mat.t()
.
@deprecated Use class ArucoDetector::refineDetectedMarkers
Python prototype (for reference only):
refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners[, cameraMatrix[, distCoeffs[, minRepDistance[, errorCorrectionRate[, checkAllOrders[, recoveredIdxs[, parameters]]]]]]]) -> detectedCorners, detectedIds, rejectedCorners, recoveredIdxs
@spec testCharucoCornersCollinear( Evision.ArUco.CharucoBoard.t(), Evision.Mat.maybe_mat_in() ) :: boolean() | {:error, String.t()}
testCharucoCornersCollinear
Positional Arguments
- board:
Evision.ArUco.CharucoBoard
- charucoIds:
Evision.Mat
Return
- retval:
bool
@deprecated Use CharucoBoard::checkCharucoCornersCollinear
Python prototype (for reference only):
testCharucoCornersCollinear(board, charucoIds) -> retval