ImageProcess/Archive/ios/opencv2.framework/Versions/A/Headers/Calib3d.h

//
// This file is auto-generated. Please don't modify it!
//
#pragma once

#ifdef __cplusplus
//#import "opencv.hpp"
#import "opencv2/calib3d.hpp"
#else
#define CV_EXPORTS
#endif

#import <Foundation/Foundation.h>

@class CirclesGridFinderParameters;
@class Double3;
@class Mat;
@class Point2d;
@class Rect2i;
@class Scalar;
@class Size2i;
@class TermCriteria;
@class UsacParams;


// C++: enum HandEyeCalibrationMethod (cv.HandEyeCalibrationMethod)
typedef NS_ENUM(int, HandEyeCalibrationMethod) {
    CALIB_HAND_EYE_TSAI = 0,
    CALIB_HAND_EYE_PARK = 1,
    CALIB_HAND_EYE_HORAUD = 2,
    CALIB_HAND_EYE_ANDREFF = 3,
    CALIB_HAND_EYE_DANIILIDIS = 4
};


// C++: enum LocalOptimMethod (cv.LocalOptimMethod)
typedef NS_ENUM(int, LocalOptimMethod) {
    LOCAL_OPTIM_NULL = 0,
    LOCAL_OPTIM_INNER_LO = 1,
    LOCAL_OPTIM_INNER_AND_ITER_LO = 2,
    LOCAL_OPTIM_GC = 3,
    LOCAL_OPTIM_SIGMA = 4
};


// C++: enum NeighborSearchMethod (cv.NeighborSearchMethod)
typedef NS_ENUM(int, NeighborSearchMethod) {
    NEIGH_FLANN_KNN = 0,
    NEIGH_GRID = 1,
    NEIGH_FLANN_RADIUS = 2
};


// C++: enum RobotWorldHandEyeCalibrationMethod (cv.RobotWorldHandEyeCalibrationMethod)
typedef NS_ENUM(int, RobotWorldHandEyeCalibrationMethod) {
    CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0,
    CALIB_ROBOT_WORLD_HAND_EYE_LI = 1
};


// C++: enum SamplingMethod (cv.SamplingMethod)
typedef NS_ENUM(int, SamplingMethod) {
    SAMPLING_UNIFORM = 0,
    SAMPLING_PROGRESSIVE_NAPSAC = 1,
    SAMPLING_NAPSAC = 2,
    SAMPLING_PROSAC = 3
};


// C++: enum ScoreMethod (cv.ScoreMethod)
typedef NS_ENUM(int, ScoreMethod) {
    SCORE_METHOD_RANSAC = 0,
    SCORE_METHOD_MSAC = 1,
    SCORE_METHOD_MAGSAC = 2,
    SCORE_METHOD_LMEDS = 3
};


// C++: enum SolvePnPMethod (cv.SolvePnPMethod)
typedef NS_ENUM(int, SolvePnPMethod) {
    SOLVEPNP_ITERATIVE = 0,
    SOLVEPNP_EPNP = 1,
    SOLVEPNP_P3P = 2,
    SOLVEPNP_DLS = 3,
    SOLVEPNP_UPNP = 4,
    SOLVEPNP_AP3P = 5,
    SOLVEPNP_IPPE = 6,
    SOLVEPNP_IPPE_SQUARE = 7,
    SOLVEPNP_SQPNP = 8,
    SOLVEPNP_MAX_COUNT = 8+1
};


// C++: enum UndistortTypes (cv.UndistortTypes)
typedef NS_ENUM(int, UndistortTypes) {
    PROJ_SPHERICAL_ORTHO = 0,
    PROJ_SPHERICAL_EQRECT = 1
};



NS_ASSUME_NONNULL_BEGIN

// C++: class Calib3d
/**
 * The Calib3d module
 *
 * Member classes: `UsacParams`, `CirclesGridFinderParameters`, `StereoMatcher`, `StereoBM`, `StereoSGBM`
 *
 * Member enums: `SolvePnPMethod`, `HandEyeCalibrationMethod`, `RobotWorldHandEyeCalibrationMethod`, `SamplingMethod`, `LocalOptimMethod`, `ScoreMethod`, `NeighborSearchMethod`, `GridType`, `UndistortTypes`
 */
CV_EXPORTS @interface Calib3d : NSObject

#pragma mark - Class Constants


@property (class, readonly) int CV_ITERATIVE NS_SWIFT_NAME(CV_ITERATIVE);
@property (class, readonly) int CV_EPNP NS_SWIFT_NAME(CV_EPNP);
@property (class, readonly) int CV_P3P NS_SWIFT_NAME(CV_P3P);
@property (class, readonly) int CV_DLS NS_SWIFT_NAME(CV_DLS);
@property (class, readonly) int CvLevMarq_DONE NS_SWIFT_NAME(CvLevMarq_DONE);
@property (class, readonly) int CvLevMarq_STARTED NS_SWIFT_NAME(CvLevMarq_STARTED);
@property (class, readonly) int CvLevMarq_CALC_J NS_SWIFT_NAME(CvLevMarq_CALC_J);
@property (class, readonly) int CvLevMarq_CHECK_ERR NS_SWIFT_NAME(CvLevMarq_CHECK_ERR);
@property (class, readonly) int LMEDS NS_SWIFT_NAME(LMEDS);
@property (class, readonly) int RANSAC NS_SWIFT_NAME(RANSAC);
@property (class, readonly) int RHO NS_SWIFT_NAME(RHO);
@property (class, readonly) int USAC_DEFAULT NS_SWIFT_NAME(USAC_DEFAULT);
@property (class, readonly) int USAC_PARALLEL NS_SWIFT_NAME(USAC_PARALLEL);
@property (class, readonly) int USAC_FM_8PTS NS_SWIFT_NAME(USAC_FM_8PTS);
@property (class, readonly) int USAC_FAST NS_SWIFT_NAME(USAC_FAST);
@property (class, readonly) int USAC_ACCURATE NS_SWIFT_NAME(USAC_ACCURATE);
@property (class, readonly) int USAC_PROSAC NS_SWIFT_NAME(USAC_PROSAC);
@property (class, readonly) int USAC_MAGSAC NS_SWIFT_NAME(USAC_MAGSAC);
@property (class, readonly) int CALIB_CB_ADAPTIVE_THRESH NS_SWIFT_NAME(CALIB_CB_ADAPTIVE_THRESH);
@property (class, readonly) int CALIB_CB_NORMALIZE_IMAGE NS_SWIFT_NAME(CALIB_CB_NORMALIZE_IMAGE);
@property (class, readonly) int CALIB_CB_FILTER_QUADS NS_SWIFT_NAME(CALIB_CB_FILTER_QUADS);
@property (class, readonly) int CALIB_CB_FAST_CHECK NS_SWIFT_NAME(CALIB_CB_FAST_CHECK);
@property (class, readonly) int CALIB_CB_EXHAUSTIVE NS_SWIFT_NAME(CALIB_CB_EXHAUSTIVE);
@property (class, readonly) int CALIB_CB_ACCURACY NS_SWIFT_NAME(CALIB_CB_ACCURACY);
@property (class, readonly) int CALIB_CB_LARGER NS_SWIFT_NAME(CALIB_CB_LARGER);
@property (class, readonly) int CALIB_CB_MARKER NS_SWIFT_NAME(CALIB_CB_MARKER);
@property (class, readonly) int CALIB_CB_SYMMETRIC_GRID NS_SWIFT_NAME(CALIB_CB_SYMMETRIC_GRID);
@property (class, readonly) int CALIB_CB_ASYMMETRIC_GRID NS_SWIFT_NAME(CALIB_CB_ASYMMETRIC_GRID);
@property (class, readonly) int CALIB_CB_CLUSTERING NS_SWIFT_NAME(CALIB_CB_CLUSTERING);
@property (class, readonly) int CALIB_NINTRINSIC NS_SWIFT_NAME(CALIB_NINTRINSIC);
@property (class, readonly) int CALIB_USE_INTRINSIC_GUESS NS_SWIFT_NAME(CALIB_USE_INTRINSIC_GUESS);
@property (class, readonly) int CALIB_FIX_ASPECT_RATIO NS_SWIFT_NAME(CALIB_FIX_ASPECT_RATIO);
@property (class, readonly) int CALIB_FIX_PRINCIPAL_POINT NS_SWIFT_NAME(CALIB_FIX_PRINCIPAL_POINT);
@property (class, readonly) int CALIB_ZERO_TANGENT_DIST NS_SWIFT_NAME(CALIB_ZERO_TANGENT_DIST);
@property (class, readonly) int CALIB_FIX_FOCAL_LENGTH NS_SWIFT_NAME(CALIB_FIX_FOCAL_LENGTH);
@property (class, readonly) int CALIB_FIX_K1 NS_SWIFT_NAME(CALIB_FIX_K1);
@property (class, readonly) int CALIB_FIX_K2 NS_SWIFT_NAME(CALIB_FIX_K2);
@property (class, readonly) int CALIB_FIX_K3 NS_SWIFT_NAME(CALIB_FIX_K3);
@property (class, readonly) int CALIB_FIX_K4 NS_SWIFT_NAME(CALIB_FIX_K4);
@property (class, readonly) int CALIB_FIX_K5 NS_SWIFT_NAME(CALIB_FIX_K5);
@property (class, readonly) int CALIB_FIX_K6 NS_SWIFT_NAME(CALIB_FIX_K6);
@property (class, readonly) int CALIB_RATIONAL_MODEL NS_SWIFT_NAME(CALIB_RATIONAL_MODEL);
@property (class, readonly) int CALIB_THIN_PRISM_MODEL NS_SWIFT_NAME(CALIB_THIN_PRISM_MODEL);
@property (class, readonly) int CALIB_FIX_S1_S2_S3_S4 NS_SWIFT_NAME(CALIB_FIX_S1_S2_S3_S4);
@property (class, readonly) int CALIB_TILTED_MODEL NS_SWIFT_NAME(CALIB_TILTED_MODEL);
@property (class, readonly) int CALIB_FIX_TAUX_TAUY NS_SWIFT_NAME(CALIB_FIX_TAUX_TAUY);
@property (class, readonly) int CALIB_USE_QR NS_SWIFT_NAME(CALIB_USE_QR);
@property (class, readonly) int CALIB_FIX_TANGENT_DIST NS_SWIFT_NAME(CALIB_FIX_TANGENT_DIST);
@property (class, readonly) int CALIB_FIX_INTRINSIC NS_SWIFT_NAME(CALIB_FIX_INTRINSIC);
@property (class, readonly) int CALIB_SAME_FOCAL_LENGTH NS_SWIFT_NAME(CALIB_SAME_FOCAL_LENGTH);
@property (class, readonly) int CALIB_ZERO_DISPARITY NS_SWIFT_NAME(CALIB_ZERO_DISPARITY);
@property (class, readonly) int CALIB_USE_LU NS_SWIFT_NAME(CALIB_USE_LU);
@property (class, readonly) int CALIB_USE_EXTRINSIC_GUESS NS_SWIFT_NAME(CALIB_USE_EXTRINSIC_GUESS);
@property (class, readonly) int FM_7POINT NS_SWIFT_NAME(FM_7POINT);
@property (class, readonly) int FM_8POINT NS_SWIFT_NAME(FM_8POINT);
@property (class, readonly) int FM_LMEDS NS_SWIFT_NAME(FM_LMEDS);
@property (class, readonly) int FM_RANSAC NS_SWIFT_NAME(FM_RANSAC);
@property (class, readonly) int CALIB_RECOMPUTE_EXTRINSIC NS_SWIFT_NAME(CALIB_RECOMPUTE_EXTRINSIC);
@property (class, readonly) int CALIB_CHECK_COND NS_SWIFT_NAME(CALIB_CHECK_COND);
@property (class, readonly) int CALIB_FIX_SKEW NS_SWIFT_NAME(CALIB_FIX_SKEW);

#pragma mark - Methods


//
//  void cv::Rodrigues(Mat src, Mat& dst, Mat& jacobian = Mat())
//
/**
 * Converts a rotation matrix to a rotation vector or vice versa.
 *
 * @param src Input rotation vector (3x1 or 1x3) or rotation matrix (3x3).
 * @param dst Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively.
 * @param jacobian Optional output Jacobian matrix, 3x9 or 9x3, which is a matrix of partial
 * derivatives of the output array components with respect to the input array components.
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \begin{array}{l} \theta \leftarrow norm(r) \\ r  \leftarrow r/ \theta \\ R =  \cos(\theta) I + (1- \cos{\theta} ) r r^T +  \sin(\theta) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}$$`
 *
 * Inverse transformation can be also done easily, since
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}$$`
 *
 * A rotation vector is a convenient and most compact representation of a rotation matrix (since any
 * rotation matrix has just 3 degrees of freedom). The representation is used in the global 3D geometry
 * optimization procedures like REF: calibrateCamera, REF: stereoCalibrate, or REF: solvePnP .
 *
 * NOTE: More information about the computation of the derivative of a 3D rotation matrix with respect to its exponential coordinate
 * can be found in:
 *     - A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi CITE: Gallego2014ACF
 *
 * NOTE: Useful information on SE(3) and Lie Groups can be found in:
 *     - A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco CITE: blanco2010tutorial
 *     - Lie Groups for 2D and 3D Transformation, Ethan Eade CITE: Eade17
 *     - A micro Lie theory for state estimation in robotics, Joan Solà, Jérémie Deray, Dinesh Atchuthan CITE: Sol2018AML
 */
+ (void)Rodrigues:(Mat*)src dst:(Mat*)dst jacobian:(Mat*)jacobian NS_SWIFT_NAME(Rodrigues(src:dst:jacobian:));

/**
 * Converts a rotation matrix to a rotation vector or vice versa.
 *
 * @param src Input rotation vector (3x1 or 1x3) or rotation matrix (3x3).
 * @param dst Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively.
 * derivatives of the output array components with respect to the input array components.
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \begin{array}{l} \theta \leftarrow norm(r) \\ r  \leftarrow r/ \theta \\ R =  \cos(\theta) I + (1- \cos{\theta} ) r r^T +  \sin(\theta) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} \end{array}$$`
 *
 * Inverse transformation can be also done easily, since
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \sin ( \theta ) \vecthreethree{0}{-r_z}{r_y}{r_z}{0}{-r_x}{-r_y}{r_x}{0} = \frac{R - R^T}{2}$$`
 *
 * A rotation vector is a convenient and most compact representation of a rotation matrix (since any
 * rotation matrix has just 3 degrees of freedom). The representation is used in the global 3D geometry
 * optimization procedures like REF: calibrateCamera, REF: stereoCalibrate, or REF: solvePnP .
 *
 * NOTE: More information about the computation of the derivative of a 3D rotation matrix with respect to its exponential coordinate
 * can be found in:
 *     - A Compact Formula for the Derivative of a 3-D Rotation in Exponential Coordinates, Guillermo Gallego, Anthony J. Yezzi CITE: Gallego2014ACF
 *
 * NOTE: Useful information on SE(3) and Lie Groups can be found in:
 *     - A tutorial on SE(3) transformation parameterizations and on-manifold optimization, Jose-Luis Blanco CITE: blanco2010tutorial
 *     - Lie Groups for 2D and 3D Transformation, Ethan Eade CITE: Eade17
 *     - A micro Lie theory for state estimation in robotics, Joan Solà, Jérémie Deray, Dinesh Atchuthan CITE: Sol2018AML
 */
+ (void)Rodrigues:(Mat*)src dst:(Mat*)dst NS_SWIFT_NAME(Rodrigues(src:dst:));


//
//  Mat cv::findHomography(Mat srcPoints, Mat dstPoints, int method = 0, double ransacReprojThreshold = 3, Mat& mask = Mat(), int maxIters = 2000, double confidence = 0.995)
//
/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * @param method Method used to compute a homography matrix. The following methods are possible:
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * @param ransacReprojThreshold Maximum allowed reprojection error to treat a point pair as an inlier
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * @param mask Optional output mask set by a robust method ( RANSAC or LMeDS ). Note that the input
 * mask values are ignored.
 * @param maxIters The maximum number of RANSAC iterations.
 * @param confidence Confidence level, between 0 and 1.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold mask:(Mat*)mask maxIters:(int)maxIters confidence:(double)confidence NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:method:ransacReprojThreshold:mask:maxIters:confidence:));

/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * @param method Method used to compute a homography matrix. The following methods are possible:
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * @param ransacReprojThreshold Maximum allowed reprojection error to treat a point pair as an inlier
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * @param mask Optional output mask set by a robust method ( RANSAC or LMeDS ). Note that the input
 * mask values are ignored.
 * @param maxIters The maximum number of RANSAC iterations.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold mask:(Mat*)mask maxIters:(int)maxIters NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:method:ransacReprojThreshold:mask:maxIters:));

/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * @param method Method used to compute a homography matrix. The following methods are possible:
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * @param ransacReprojThreshold Maximum allowed reprojection error to treat a point pair as an inlier
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * @param mask Optional output mask set by a robust method ( RANSAC or LMeDS ). Note that the input
 * mask values are ignored.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold mask:(Mat*)mask NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:method:ransacReprojThreshold:mask:));

/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * @param method Method used to compute a homography matrix. The following methods are possible:
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * @param ransacReprojThreshold Maximum allowed reprojection error to treat a point pair as an inlier
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * mask values are ignored.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:method:ransacReprojThreshold:));

/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * @param method Method used to compute a homography matrix. The following methods are possible:
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * mask values are ignored.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints method:(int)method NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:method:));

/**
 * Finds a perspective transformation between two planes.
 *
 * @param srcPoints Coordinates of the points in the original plane, a matrix of the type CV_32FC2
 * or vector\<Point2f\> .
 * @param dstPoints Coordinates of the points in the target plane, a matrix of the type CV_32FC2 or
 * a vector\<Point2f\> .
 * -   **0** - a regular method using all the points, i.e., the least squares method
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * -   REF: RHO - PROSAC-based robust method
 * (used in the RANSAC and RHO methods only). That is, if
 * `$$\| \texttt{dstPoints} _i -  \texttt{convertPointsHomogeneous} ( \texttt{H} * \texttt{srcPoints} _i) \|_2  >  \texttt{ransacReprojThreshold}$$`
 * then the point `$$i$$` is considered as an outlier. If srcPoints and dstPoints are measured in pixels,
 * it usually makes sense to set this parameter somewhere in the range of 1 to 10.
 * mask values are ignored.
 *
 * The function finds and returns the perspective transformation `$$H$$` between the source and the
 * destination planes:
 *
 * `$$s_i  \vecthree{x'_i}{y'_i}{1} \sim H  \vecthree{x_i}{y_i}{1}$$`
 *
 * so that the back-projection error
 *
 * `$$\sum _i \left ( x'_i- \frac{h_{11} x_i + h_{12} y_i + h_{13}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2+ \left ( y'_i- \frac{h_{21} x_i + h_{22} y_i + h_{23}}{h_{31} x_i + h_{32} y_i + h_{33}} \right )^2$$`
 *
 * is minimized. If the parameter method is set to the default value 0, the function uses all the point
 * pairs to compute an initial homography estimate with a simple least-squares scheme.
 *
 * However, if not all of the point pairs ( `$$srcPoints_i$$`, `$$dstPoints_i$$` ) fit the rigid perspective
 * transformation (that is, there are some outliers), this initial estimate will be poor. In this case,
 * you can use one of the three robust methods. The methods RANSAC, LMeDS and RHO try many different
 * random subsets of the corresponding point pairs (of four pairs each, collinear pairs are discarded), estimate the homography matrix
 * using this subset and a simple least-squares algorithm, and then compute the quality/goodness of the
 * computed homography (which is the number of inliers for RANSAC or the least median re-projection error for
 * LMeDS). The best subset is then used to produce the initial estimate of the homography matrix and
 * the mask of inliers/outliers.
 *
 * Regardless of the method, robust or not, the computed homography matrix is refined further (using
 * inliers only in case of a robust method) with the Levenberg-Marquardt method to reduce the
 * re-projection error even more.
 *
 * The methods RANSAC and RHO can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers. Finally, if there are no outliers and the
 * noise is rather small, use the default method (method=0).
 *
 * The function is used to find initial intrinsic and extrinsic matrices. Homography matrix is
 * determined up to a scale. Thus, it is normalized so that `$$h_{33}=1$$`. Note that whenever an `$$H$$` matrix
 * cannot be estimated, an empty one will be returned.
 *
 * @sa
 * getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective,
 * perspectiveTransform
 */
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:));


//
//  Mat cv::findHomography(Mat srcPoints, Mat dstPoints, Mat& mask, UsacParams params)
//
+ (Mat*)findHomography:(Mat*)srcPoints dstPoints:(Mat*)dstPoints mask:(Mat*)mask params:(UsacParams*)params NS_SWIFT_NAME(findHomography(srcPoints:dstPoints:mask:params:));


//
//  Vec3d cv::RQDecomp3x3(Mat src, Mat& mtxR, Mat& mtxQ, Mat& Qx = Mat(), Mat& Qy = Mat(), Mat& Qz = Mat())
//
/**
 * Computes an RQ decomposition of 3x3 matrices.
 *
 * @param src 3x3 input matrix.
 * @param mtxR Output 3x3 upper-triangular matrix.
 * @param mtxQ Output 3x3 orthogonal matrix.
 * @param Qx Optional output 3x3 rotation matrix around x-axis.
 * @param Qy Optional output 3x3 rotation matrix around y-axis.
 * @param Qz Optional output 3x3 rotation matrix around z-axis.
 *
 * The function computes a RQ decomposition using the given rotations. This function is used in
 * #decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera
 * and a rotation matrix.
 *
 * It optionally returns three rotation matrices, one for each axis, and the three Euler angles in
 * degrees (as the return value) that could be used in OpenGL. Note, there is always more than one
 * sequence of rotations about the three principal axes that results in the same orientation of an
 * object, e.g. see CITE: Slabaugh . Returned tree rotation matrices and corresponding three Euler angles
 * are only one of the possible solutions.
 */
+ (Double3*)RQDecomp3x3:(Mat*)src mtxR:(Mat*)mtxR mtxQ:(Mat*)mtxQ Qx:(Mat*)Qx Qy:(Mat*)Qy Qz:(Mat*)Qz NS_SWIFT_NAME(RQDecomp3x3(src:mtxR:mtxQ:Qx:Qy:Qz:));

/**
 * Computes an RQ decomposition of 3x3 matrices.
 *
 * @param src 3x3 input matrix.
 * @param mtxR Output 3x3 upper-triangular matrix.
 * @param mtxQ Output 3x3 orthogonal matrix.
 * @param Qx Optional output 3x3 rotation matrix around x-axis.
 * @param Qy Optional output 3x3 rotation matrix around y-axis.
 *
 * The function computes a RQ decomposition using the given rotations. This function is used in
 * #decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera
 * and a rotation matrix.
 *
 * It optionally returns three rotation matrices, one for each axis, and the three Euler angles in
 * degrees (as the return value) that could be used in OpenGL. Note, there is always more than one
 * sequence of rotations about the three principal axes that results in the same orientation of an
 * object, e.g. see CITE: Slabaugh . Returned tree rotation matrices and corresponding three Euler angles
 * are only one of the possible solutions.
 */
+ (Double3*)RQDecomp3x3:(Mat*)src mtxR:(Mat*)mtxR mtxQ:(Mat*)mtxQ Qx:(Mat*)Qx Qy:(Mat*)Qy NS_SWIFT_NAME(RQDecomp3x3(src:mtxR:mtxQ:Qx:Qy:));

/**
 * Computes an RQ decomposition of 3x3 matrices.
 *
 * @param src 3x3 input matrix.
 * @param mtxR Output 3x3 upper-triangular matrix.
 * @param mtxQ Output 3x3 orthogonal matrix.
 * @param Qx Optional output 3x3 rotation matrix around x-axis.
 *
 * The function computes a RQ decomposition using the given rotations. This function is used in
 * #decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera
 * and a rotation matrix.
 *
 * It optionally returns three rotation matrices, one for each axis, and the three Euler angles in
 * degrees (as the return value) that could be used in OpenGL. Note, there is always more than one
 * sequence of rotations about the three principal axes that results in the same orientation of an
 * object, e.g. see CITE: Slabaugh . Returned tree rotation matrices and corresponding three Euler angles
 * are only one of the possible solutions.
 */
+ (Double3*)RQDecomp3x3:(Mat*)src mtxR:(Mat*)mtxR mtxQ:(Mat*)mtxQ Qx:(Mat*)Qx NS_SWIFT_NAME(RQDecomp3x3(src:mtxR:mtxQ:Qx:));

/**
 * Computes an RQ decomposition of 3x3 matrices.
 *
 * @param src 3x3 input matrix.
 * @param mtxR Output 3x3 upper-triangular matrix.
 * @param mtxQ Output 3x3 orthogonal matrix.
 *
 * The function computes a RQ decomposition using the given rotations. This function is used in
 * #decomposeProjectionMatrix to decompose the left 3x3 submatrix of a projection matrix into a camera
 * and a rotation matrix.
 *
 * It optionally returns three rotation matrices, one for each axis, and the three Euler angles in
 * degrees (as the return value) that could be used in OpenGL. Note, there is always more than one
 * sequence of rotations about the three principal axes that results in the same orientation of an
 * object, e.g. see CITE: Slabaugh . Returned tree rotation matrices and corresponding three Euler angles
 * are only one of the possible solutions.
 */
+ (Double3*)RQDecomp3x3:(Mat*)src mtxR:(Mat*)mtxR mtxQ:(Mat*)mtxQ NS_SWIFT_NAME(RQDecomp3x3(src:mtxR:mtxQ:));


//
//  void cv::decomposeProjectionMatrix(Mat projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX = Mat(), Mat& rotMatrixY = Mat(), Mat& rotMatrixZ = Mat(), Mat& eulerAngles = Mat())
//
/**
 * Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 *
 * @param projMatrix 3x4 input projection matrix P.
 * @param cameraMatrix Output 3x3 camera intrinsic matrix `$$\cameramatrix{A}$$`.
 * @param rotMatrix Output 3x3 external rotation matrix R.
 * @param transVect Output 4x1 translation vector T.
 * @param rotMatrixX Optional 3x3 rotation matrix around x-axis.
 * @param rotMatrixY Optional 3x3 rotation matrix around y-axis.
 * @param rotMatrixZ Optional 3x3 rotation matrix around z-axis.
 * @param eulerAngles Optional three-element vector containing three Euler angles of rotation in
 * degrees.
 *
 * The function computes a decomposition of a projection matrix into a calibration and a rotation
 * matrix and the position of a camera.
 *
 * It optionally returns three rotation matrices, one for each axis, and three Euler angles that could
 * be used in OpenGL. Note, there is always more than one sequence of rotations about the three
 * principal axes that results in the same orientation of an object, e.g. see CITE: Slabaugh . Returned
 * tree rotation matrices and corresponding three Euler angles are only one of the possible solutions.
 *
 * The function is based on RQDecomp3x3 .
 */
+ (void)decomposeProjectionMatrix:(Mat*)projMatrix cameraMatrix:(Mat*)cameraMatrix rotMatrix:(Mat*)rotMatrix transVect:(Mat*)transVect rotMatrixX:(Mat*)rotMatrixX rotMatrixY:(Mat*)rotMatrixY rotMatrixZ:(Mat*)rotMatrixZ eulerAngles:(Mat*)eulerAngles NS_SWIFT_NAME(decomposeProjectionMatrix(projMatrix:cameraMatrix:rotMatrix:transVect:rotMatrixX:rotMatrixY:rotMatrixZ:eulerAngles:));

/**
 * Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 *
 * @param projMatrix 3x4 input projection matrix P.
 * @param cameraMatrix Output 3x3 camera intrinsic matrix `$$\cameramatrix{A}$$`.
 * @param rotMatrix Output 3x3 external rotation matrix R.
 * @param transVect Output 4x1 translation vector T.
 * @param rotMatrixX Optional 3x3 rotation matrix around x-axis.
 * @param rotMatrixY Optional 3x3 rotation matrix around y-axis.
 * @param rotMatrixZ Optional 3x3 rotation matrix around z-axis.
 * degrees.
 *
 * The function computes a decomposition of a projection matrix into a calibration and a rotation
 * matrix and the position of a camera.
 *
 * It optionally returns three rotation matrices, one for each axis, and three Euler angles that could
 * be used in OpenGL. Note, there is always more than one sequence of rotations about the three
 * principal axes that results in the same orientation of an object, e.g. see CITE: Slabaugh . Returned
 * tree rotation matrices and corresponding three Euler angles are only one of the possible solutions.
 *
 * The function is based on RQDecomp3x3 .
 */
+ (void)decomposeProjectionMatrix:(Mat*)projMatrix cameraMatrix:(Mat*)cameraMatrix rotMatrix:(Mat*)rotMatrix transVect:(Mat*)transVect rotMatrixX:(Mat*)rotMatrixX rotMatrixY:(Mat*)rotMatrixY rotMatrixZ:(Mat*)rotMatrixZ NS_SWIFT_NAME(decomposeProjectionMatrix(projMatrix:cameraMatrix:rotMatrix:transVect:rotMatrixX:rotMatrixY:rotMatrixZ:));

/**
 * Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 *
 * @param projMatrix 3x4 input projection matrix P.
 * @param cameraMatrix Output 3x3 camera intrinsic matrix `$$\cameramatrix{A}$$`.
 * @param rotMatrix Output 3x3 external rotation matrix R.
 * @param transVect Output 4x1 translation vector T.
 * @param rotMatrixX Optional 3x3 rotation matrix around x-axis.
 * @param rotMatrixY Optional 3x3 rotation matrix around y-axis.
 * degrees.
 *
 * The function computes a decomposition of a projection matrix into a calibration and a rotation
 * matrix and the position of a camera.
 *
 * It optionally returns three rotation matrices, one for each axis, and three Euler angles that could
 * be used in OpenGL. Note, there is always more than one sequence of rotations about the three
 * principal axes that results in the same orientation of an object, e.g. see CITE: Slabaugh . Returned
 * tree rotation matrices and corresponding three Euler angles are only one of the possible solutions.
 *
 * The function is based on RQDecomp3x3 .
 */
+ (void)decomposeProjectionMatrix:(Mat*)projMatrix cameraMatrix:(Mat*)cameraMatrix rotMatrix:(Mat*)rotMatrix transVect:(Mat*)transVect rotMatrixX:(Mat*)rotMatrixX rotMatrixY:(Mat*)rotMatrixY NS_SWIFT_NAME(decomposeProjectionMatrix(projMatrix:cameraMatrix:rotMatrix:transVect:rotMatrixX:rotMatrixY:));

/**
 * Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 *
 * @param projMatrix 3x4 input projection matrix P.
 * @param cameraMatrix Output 3x3 camera intrinsic matrix `$$\cameramatrix{A}$$`.
 * @param rotMatrix Output 3x3 external rotation matrix R.
 * @param transVect Output 4x1 translation vector T.
 * @param rotMatrixX Optional 3x3 rotation matrix around x-axis.
 * degrees.
 *
 * The function computes a decomposition of a projection matrix into a calibration and a rotation
 * matrix and the position of a camera.
 *
 * It optionally returns three rotation matrices, one for each axis, and three Euler angles that could
 * be used in OpenGL. Note, there is always more than one sequence of rotations about the three
 * principal axes that results in the same orientation of an object, e.g. see CITE: Slabaugh . Returned
 * tree rotation matrices and corresponding three Euler angles are only one of the possible solutions.
 *
 * The function is based on RQDecomp3x3 .
 */
+ (void)decomposeProjectionMatrix:(Mat*)projMatrix cameraMatrix:(Mat*)cameraMatrix rotMatrix:(Mat*)rotMatrix transVect:(Mat*)transVect rotMatrixX:(Mat*)rotMatrixX NS_SWIFT_NAME(decomposeProjectionMatrix(projMatrix:cameraMatrix:rotMatrix:transVect:rotMatrixX:));

/**
 * Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 *
 * @param projMatrix 3x4 input projection matrix P.
 * @param cameraMatrix Output 3x3 camera intrinsic matrix `$$\cameramatrix{A}$$`.
 * @param rotMatrix Output 3x3 external rotation matrix R.
 * @param transVect Output 4x1 translation vector T.
 * degrees.
 *
 * The function computes a decomposition of a projection matrix into a calibration and a rotation
 * matrix and the position of a camera.
 *
 * It optionally returns three rotation matrices, one for each axis, and three Euler angles that could
 * be used in OpenGL. Note, there is always more than one sequence of rotations about the three
 * principal axes that results in the same orientation of an object, e.g. see CITE: Slabaugh . Returned
 * tree rotation matrices and corresponding three Euler angles are only one of the possible solutions.
 *
 * The function is based on RQDecomp3x3 .
 */
+ (void)decomposeProjectionMatrix:(Mat*)projMatrix cameraMatrix:(Mat*)cameraMatrix rotMatrix:(Mat*)rotMatrix transVect:(Mat*)transVect NS_SWIFT_NAME(decomposeProjectionMatrix(projMatrix:cameraMatrix:rotMatrix:transVect:));


//
//  void cv::matMulDeriv(Mat A, Mat B, Mat& dABdA, Mat& dABdB)
//
/**
 * Computes partial derivatives of the matrix product for each multiplied matrix.
 *
 * @param A First multiplied matrix.
 * @param B Second multiplied matrix.
 * @param dABdA First output derivative matrix d(A\*B)/dA of size
 * `$$\texttt{A.rows*B.cols} \times {A.rows*A.cols}$$` .
 * @param dABdB Second output derivative matrix d(A\*B)/dB of size
 * `$$\texttt{A.rows*B.cols} \times {B.rows*B.cols}$$` .
 *
 * The function computes partial derivatives of the elements of the matrix product `$$A*B$$` with regard to
 * the elements of each of the two input matrices. The function is used to compute the Jacobian
 * matrices in #stereoCalibrate but can also be used in any other similar optimization function.
 */
+ (void)matMulDeriv:(Mat*)A B:(Mat*)B dABdA:(Mat*)dABdA dABdB:(Mat*)dABdB NS_SWIFT_NAME(matMulDeriv(A:B:dABdA:dABdB:));


//
//  void cv::composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1 = Mat(), Mat& dr3dt1 = Mat(), Mat& dr3dr2 = Mat(), Mat& dr3dt2 = Mat(), Mat& dt3dr1 = Mat(), Mat& dt3dt1 = Mat(), Mat& dt3dr2 = Mat(), Mat& dt3dt2 = Mat())
//
/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 * @param dr3dt2 Optional output derivative of rvec3 with regard to tvec2
 * @param dt3dr1 Optional output derivative of tvec3 with regard to rvec1
 * @param dt3dt1 Optional output derivative of tvec3 with regard to tvec1
 * @param dt3dr2 Optional output derivative of tvec3 with regard to rvec2
 * @param dt3dt2 Optional output derivative of tvec3 with regard to tvec2
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 dr3dt2:(Mat*)dr3dt2 dt3dr1:(Mat*)dt3dr1 dt3dt1:(Mat*)dt3dt1 dt3dr2:(Mat*)dt3dr2 dt3dt2:(Mat*)dt3dt2 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:dr3dt2:dt3dr1:dt3dt1:dt3dr2:dt3dt2:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 * @param dr3dt2 Optional output derivative of rvec3 with regard to tvec2
 * @param dt3dr1 Optional output derivative of tvec3 with regard to rvec1
 * @param dt3dt1 Optional output derivative of tvec3 with regard to tvec1
 * @param dt3dr2 Optional output derivative of tvec3 with regard to rvec2
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 dr3dt2:(Mat*)dr3dt2 dt3dr1:(Mat*)dt3dr1 dt3dt1:(Mat*)dt3dt1 dt3dr2:(Mat*)dt3dr2 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:dr3dt2:dt3dr1:dt3dt1:dt3dr2:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 * @param dr3dt2 Optional output derivative of rvec3 with regard to tvec2
 * @param dt3dr1 Optional output derivative of tvec3 with regard to rvec1
 * @param dt3dt1 Optional output derivative of tvec3 with regard to tvec1
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 dr3dt2:(Mat*)dr3dt2 dt3dr1:(Mat*)dt3dr1 dt3dt1:(Mat*)dt3dt1 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:dr3dt2:dt3dr1:dt3dt1:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 * @param dr3dt2 Optional output derivative of rvec3 with regard to tvec2
 * @param dt3dr1 Optional output derivative of tvec3 with regard to rvec1
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 dr3dt2:(Mat*)dr3dt2 dt3dr1:(Mat*)dt3dr1 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:dr3dt2:dt3dr1:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 * @param dr3dt2 Optional output derivative of rvec3 with regard to tvec2
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 dr3dt2:(Mat*)dr3dt2 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:dr3dt2:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 * @param dr3dr2 Optional output derivative of rvec3 with regard to rvec2
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 dr3dr2:(Mat*)dr3dr2 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:dr3dr2:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 * @param dr3dt1 Optional output derivative of rvec3 with regard to tvec1
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 dr3dt1:(Mat*)dr3dt1 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:dr3dt1:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 * @param dr3dr1 Optional output derivative of rvec3 with regard to rvec1
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 dr3dr1:(Mat*)dr3dr1 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:dr3dr1:));

/**
 * Combines two rotation-and-shift transformations.
 *
 * @param rvec1 First rotation vector.
 * @param tvec1 First translation vector.
 * @param rvec2 Second rotation vector.
 * @param tvec2 Second translation vector.
 * @param rvec3 Output rotation vector of the superposition.
 * @param tvec3 Output translation vector of the superposition.
 *
 * The functions compute:
 *
 * `$$\begin{array}{l} \texttt{rvec3} =  \mathrm{rodrigues} ^{-1} \left ( \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \mathrm{rodrigues} ( \texttt{rvec1} ) \right )  \\ \texttt{tvec3} =  \mathrm{rodrigues} ( \texttt{rvec2} )  \cdot \texttt{tvec1} +  \texttt{tvec2} \end{array} ,$$`
 *
 * where `$$\mathrm{rodrigues}$$` denotes a rotation vector to a rotation matrix transformation, and
 * `$$\mathrm{rodrigues}^{-1}$$` denotes the inverse transformation. See Rodrigues for details.
 *
 * Also, the functions can compute the derivatives of the output vectors with regards to the input
 * vectors (see matMulDeriv ). The functions are used inside #stereoCalibrate but can also be used in
 * your own code where Levenberg-Marquardt or another gradient-based solver is used to optimize a
 * function that contains a matrix multiplication.
 */
+ (void)composeRT:(Mat*)rvec1 tvec1:(Mat*)tvec1 rvec2:(Mat*)rvec2 tvec2:(Mat*)tvec2 rvec3:(Mat*)rvec3 tvec3:(Mat*)tvec3 NS_SWIFT_NAME(composeRT(rvec1:tvec1:rvec2:tvec2:rvec3:tvec3:));


//
//  void cv::projectPoints(Mat objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, Mat distCoeffs, Mat& imagePoints, Mat& jacobian = Mat(), double aspectRatio = 0)
//
/**
 * Projects 3D points to an image plane.
 *
 * @param objectPoints Array of object points expressed wrt. the world coordinate frame. A 3xN/Nx3
 * 1-channel or 1xN/Nx1 3-channel (or vector\<Point3f\> ), where N is the number of points in the view.
 * @param rvec The rotation vector (REF: Rodrigues) that, together with tvec, performs a change of
 * basis from world to camera coordinate system, see REF: calibrateCamera for details.
 * @param tvec The translation vector, see parameter description above.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$` . If the vector is empty, the zero distortion coefficients are assumed.
 * @param imagePoints Output array of image points, 1xN/Nx1 2-channel, or
 * vector\<Point2f\> .
 * @param jacobian Optional output 2Nx(10+\<numDistCoeffs\>) jacobian matrix of derivatives of image
 * points with respect to components of the rotation vector, translation vector, focal lengths,
 * coordinates of the principal point and the distortion coefficients. In the old interface different
 * components of the jacobian are returned via different output parameters.
 * @param aspectRatio Optional "fixed aspect ratio" parameter. If the parameter is not 0, the
 * function assumes that the aspect ratio (`$$f_x / f_y$$`) is fixed and correspondingly adjusts the
 * jacobian matrix.
 *
 * The function computes the 2D projections of 3D points to the image plane, given intrinsic and
 * extrinsic camera parameters. Optionally, the function computes Jacobians -matrices of partial
 * derivatives of image points coordinates (as functions of all the input parameters) with respect to
 * the particular parameters, intrinsic and/or extrinsic. The Jacobians are used during the global
 * optimization in REF: calibrateCamera, REF: solvePnP, and REF: stereoCalibrate. The function itself
 * can also be used to compute a re-projection error, given the current intrinsic and extrinsic
 * parameters.
 *
 * NOTE: By setting rvec = tvec = `$$[0, 0, 0]$$`, or by setting cameraMatrix to a 3x3 identity matrix,
 * or by passing zero distortion coefficients, one can get various useful partial cases of the
 * function. This means, one can compute the distorted coordinates for a sparse set of points or apply
 * a perspective transformation (and also compute the derivatives) in the ideal zero-distortion setup.
 */
+ (void)projectPoints:(Mat*)objectPoints rvec:(Mat*)rvec tvec:(Mat*)tvec cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imagePoints:(Mat*)imagePoints jacobian:(Mat*)jacobian aspectRatio:(double)aspectRatio NS_SWIFT_NAME(projectPoints(objectPoints:rvec:tvec:cameraMatrix:distCoeffs:imagePoints:jacobian:aspectRatio:));

/**
 * Projects 3D points to an image plane.
 *
 * @param objectPoints Array of object points expressed wrt. the world coordinate frame. A 3xN/Nx3
 * 1-channel or 1xN/Nx1 3-channel (or vector\<Point3f\> ), where N is the number of points in the view.
 * @param rvec The rotation vector (REF: Rodrigues) that, together with tvec, performs a change of
 * basis from world to camera coordinate system, see REF: calibrateCamera for details.
 * @param tvec The translation vector, see parameter description above.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$` . If the vector is empty, the zero distortion coefficients are assumed.
 * @param imagePoints Output array of image points, 1xN/Nx1 2-channel, or
 * vector\<Point2f\> .
 * @param jacobian Optional output 2Nx(10+\<numDistCoeffs\>) jacobian matrix of derivatives of image
 * points with respect to components of the rotation vector, translation vector, focal lengths,
 * coordinates of the principal point and the distortion coefficients. In the old interface different
 * components of the jacobian are returned via different output parameters.
 * function assumes that the aspect ratio (`$$f_x / f_y$$`) is fixed and correspondingly adjusts the
 * jacobian matrix.
 *
 * The function computes the 2D projections of 3D points to the image plane, given intrinsic and
 * extrinsic camera parameters. Optionally, the function computes Jacobians -matrices of partial
 * derivatives of image points coordinates (as functions of all the input parameters) with respect to
 * the particular parameters, intrinsic and/or extrinsic. The Jacobians are used during the global
 * optimization in REF: calibrateCamera, REF: solvePnP, and REF: stereoCalibrate. The function itself
 * can also be used to compute a re-projection error, given the current intrinsic and extrinsic
 * parameters.
 *
 * NOTE: By setting rvec = tvec = `$$[0, 0, 0]$$`, or by setting cameraMatrix to a 3x3 identity matrix,
 * or by passing zero distortion coefficients, one can get various useful partial cases of the
 * function. This means, one can compute the distorted coordinates for a sparse set of points or apply
 * a perspective transformation (and also compute the derivatives) in the ideal zero-distortion setup.
 */
+ (void)projectPoints:(Mat*)objectPoints rvec:(Mat*)rvec tvec:(Mat*)tvec cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imagePoints:(Mat*)imagePoints jacobian:(Mat*)jacobian NS_SWIFT_NAME(projectPoints(objectPoints:rvec:tvec:cameraMatrix:distCoeffs:imagePoints:jacobian:));

/**
 * Projects 3D points to an image plane.
 *
 * @param objectPoints Array of object points expressed wrt. the world coordinate frame. A 3xN/Nx3
 * 1-channel or 1xN/Nx1 3-channel (or vector\<Point3f\> ), where N is the number of points in the view.
 * @param rvec The rotation vector (REF: Rodrigues) that, together with tvec, performs a change of
 * basis from world to camera coordinate system, see REF: calibrateCamera for details.
 * @param tvec The translation vector, see parameter description above.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$` . If the vector is empty, the zero distortion coefficients are assumed.
 * @param imagePoints Output array of image points, 1xN/Nx1 2-channel, or
 * vector\<Point2f\> .
 * points with respect to components of the rotation vector, translation vector, focal lengths,
 * coordinates of the principal point and the distortion coefficients. In the old interface different
 * components of the jacobian are returned via different output parameters.
 * function assumes that the aspect ratio (`$$f_x / f_y$$`) is fixed and correspondingly adjusts the
 * jacobian matrix.
 *
 * The function computes the 2D projections of 3D points to the image plane, given intrinsic and
 * extrinsic camera parameters. Optionally, the function computes Jacobians -matrices of partial
 * derivatives of image points coordinates (as functions of all the input parameters) with respect to
 * the particular parameters, intrinsic and/or extrinsic. The Jacobians are used during the global
 * optimization in REF: calibrateCamera, REF: solvePnP, and REF: stereoCalibrate. The function itself
 * can also be used to compute a re-projection error, given the current intrinsic and extrinsic
 * parameters.
 *
 * NOTE: By setting rvec = tvec = `$$[0, 0, 0]$$`, or by setting cameraMatrix to a 3x3 identity matrix,
 * or by passing zero distortion coefficients, one can get various useful partial cases of the
 * function. This means, one can compute the distorted coordinates for a sparse set of points or apply
 * a perspective transformation (and also compute the derivatives) in the ideal zero-distortion setup.
 */
+ (void)projectPoints:(Mat*)objectPoints rvec:(Mat*)rvec tvec:(Mat*)tvec cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imagePoints:(Mat*)imagePoints NS_SWIFT_NAME(projectPoints(objectPoints:rvec:tvec:cameraMatrix:distCoeffs:imagePoints:));


//
//  bool cv::solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE)
//
/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns the rotation and the translation vectors that transform a 3D point expressed in the object
 * coordinate frame to the camera coordinate frame, using different methods:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): need 4 input points to return a unique solution.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param flags Method for solving a PnP problem: see REF: calib3d_solvePnP_flags
 *
 * More information about Perspective-n-Points is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 *     -  With REF: SOLVEPNP_SQPNP input points must be >= 3
 */
+ (BOOL)solvePnP:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess flags:(int)flags NS_SWIFT_NAME(solvePnP(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:flags:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns the rotation and the translation vectors that transform a 3D point expressed in the object
 * coordinate frame to the camera coordinate frame, using different methods:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): need 4 input points to return a unique solution.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 *
 * More information about Perspective-n-Points is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 *     -  With REF: SOLVEPNP_SQPNP input points must be >= 3
 */
+ (BOOL)solvePnP:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess NS_SWIFT_NAME(solvePnP(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns the rotation and the translation vectors that transform a 3D point expressed in the object
 * coordinate frame to the camera coordinate frame, using different methods:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): need 4 input points to return a unique solution.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 *
 * More information about Perspective-n-Points is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 *     -  With REF: SOLVEPNP_SQPNP input points must be >= 3
 */
+ (BOOL)solvePnP:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec NS_SWIFT_NAME(solvePnP(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:));


//
//  bool cv::solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0, double confidence = 0.99, Mat& inliers = Mat(), int flags = SOLVEPNP_ITERATIVE)
//
/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param iterationsCount Number of iterations.
 * @param reprojectionError Inlier threshold value used by the RANSAC procedure. The parameter value
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 * @param confidence The probability that the algorithm produces a useful result.
 * @param inliers Output vector that contains indices of inliers in objectPoints and imagePoints .
 * @param flags Method for solving a PnP problem (see REF: solvePnP ).
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess iterationsCount:(int)iterationsCount reprojectionError:(float)reprojectionError confidence:(double)confidence inliers:(Mat*)inliers flags:(int)flags NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:iterationsCount:reprojectionError:confidence:inliers:flags:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param iterationsCount Number of iterations.
 * @param reprojectionError Inlier threshold value used by the RANSAC procedure. The parameter value
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 * @param confidence The probability that the algorithm produces a useful result.
 * @param inliers Output vector that contains indices of inliers in objectPoints and imagePoints .
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess iterationsCount:(int)iterationsCount reprojectionError:(float)reprojectionError confidence:(double)confidence inliers:(Mat*)inliers NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:iterationsCount:reprojectionError:confidence:inliers:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param iterationsCount Number of iterations.
 * @param reprojectionError Inlier threshold value used by the RANSAC procedure. The parameter value
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 * @param confidence The probability that the algorithm produces a useful result.
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess iterationsCount:(int)iterationsCount reprojectionError:(float)reprojectionError confidence:(double)confidence NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:iterationsCount:reprojectionError:confidence:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param iterationsCount Number of iterations.
 * @param reprojectionError Inlier threshold value used by the RANSAC procedure. The parameter value
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess iterationsCount:(int)iterationsCount reprojectionError:(float)reprojectionError NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:iterationsCount:reprojectionError:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param iterationsCount Number of iterations.
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess iterationsCount:(int)iterationsCount NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:iterationsCount:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * @param useExtrinsicGuess Parameter used for REF: SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec useExtrinsicGuess:(BOOL)useExtrinsicGuess NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:));

/**
 * Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Output translation vector.
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * is the maximum allowed distance between the observed and computed point projections to consider it
 * an inlier.
 *
 * The function estimates an object pose given a set of object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients. This function finds such
 * a pose that minimizes reprojection error, that is, the sum of squared distances between the observed
 * projections imagePoints and the projected (using REF: projectPoints ) objectPoints. The use of RANSAC
 * makes the function resistant to outliers.
 *
 * NOTE:
 *    -   An example of how to use solvePNPRansac for object detection can be found at
 *         opencv_source_code/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/
 *    -   The default method used to estimate the camera pose for the Minimal Sample Sets step
 *        is #SOLVEPNP_EPNP. Exceptions are:
 *          - if you choose #SOLVEPNP_P3P or #SOLVEPNP_AP3P, these methods will be used.
 *          - if the number of input points is equal to 4, #SOLVEPNP_P3P is used.
 *    -   The method used to estimate the camera pose using all the inliers is defined by the
 *        flags parameters unless it is equal to #SOLVEPNP_P3P or #SOLVEPNP_AP3P. In this case,
 *        the method #SOLVEPNP_EPNP will be used instead.
 */
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:));


//
//  bool cv::solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat& cameraMatrix, Mat distCoeffs, Mat& rvec, Mat& tvec, Mat& inliers, UsacParams params = UsacParams())
//
+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec inliers:(Mat*)inliers params:(UsacParams*)params NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:inliers:params:));

+ (BOOL)solvePnPRansac:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec inliers:(Mat*)inliers NS_SWIFT_NAME(solvePnPRansac(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:inliers:));


//
//  int cv::solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags)
//
/**
 * Finds an object pose from 3 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, 3x3 1-channel or
 * 1x3/3x1 3-channel. vector\<Point3f\> can be also passed here.
 * @param imagePoints Array of corresponding image points, 3x2 1-channel or 1x3/3x1 2-channel.
 *  vector\<Point2f\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system. A P3P problem has up to 4 solutions.
 * @param tvecs Output translation vectors.
 * @param flags Method for solving a P3P problem:
 * -   REF: SOLVEPNP_P3P Method is based on the paper of X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang
 * "Complete Solution Classification for the Perspective-Three-Point Problem" (CITE: gao2003complete).
 * -   REF: SOLVEPNP_AP3P Method is based on the paper of T. Ke and S. Roumeliotis.
 * "An Efficient Algebraic Solution to the Perspective-Three-Point Problem" (CITE: Ke17).
 *
 * The function estimates the object pose given 3 object points, their corresponding image
 * projections, as well as the camera intrinsic matrix and the distortion coefficients.
 *
 * NOTE:
 * The solutions are sorted by reprojection errors (lowest to highest).
 */
+ (int)solveP3P:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs flags:(int)flags NS_SWIFT_NAME(solveP3P(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:flags:));


//
//  void cv::solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat& rvec, Mat& tvec, TermCriteria criteria = TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 20, FLT_EPSILON))
//
/**
 * Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
 * to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel,
 * where N is the number of points. vector\<Point3d\> can also be passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can also be passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Input/Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system. Input values are used as an initial solution.
 * @param tvec Input/Output translation vector. Input values are used as an initial solution.
 * @param criteria Criteria when to stop the Levenberg-Marquard iterative algorithm.
 *
 * The function refines the object pose given at least 3 object points, their corresponding image
 * projections, an initial solution for the rotation and translation vector,
 * as well as the camera intrinsic matrix and the distortion coefficients.
 * The function minimizes the projection error with respect to the rotation and the translation vectors, according
 * to a Levenberg-Marquardt iterative minimization CITE: Madsen04 CITE: Eade13 process.
 */
+ (void)solvePnPRefineLM:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec criteria:(TermCriteria*)criteria NS_SWIFT_NAME(solvePnPRefineLM(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:criteria:));

/**
 * Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
 * to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel,
 * where N is the number of points. vector\<Point3d\> can also be passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can also be passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Input/Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system. Input values are used as an initial solution.
 * @param tvec Input/Output translation vector. Input values are used as an initial solution.
 *
 * The function refines the object pose given at least 3 object points, their corresponding image
 * projections, an initial solution for the rotation and translation vector,
 * as well as the camera intrinsic matrix and the distortion coefficients.
 * The function minimizes the projection error with respect to the rotation and the translation vectors, according
 * to a Levenberg-Marquardt iterative minimization CITE: Madsen04 CITE: Eade13 process.
 */
+ (void)solvePnPRefineLM:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec NS_SWIFT_NAME(solvePnPRefineLM(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:));


//
//  void cv::solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat& rvec, Mat& tvec, TermCriteria criteria = TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 20, FLT_EPSILON), double VVSlambda = 1)
//
/**
 * Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
 * to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel,
 * where N is the number of points. vector\<Point3d\> can also be passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can also be passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Input/Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system. Input values are used as an initial solution.
 * @param tvec Input/Output translation vector. Input values are used as an initial solution.
 * @param criteria Criteria when to stop the Levenberg-Marquard iterative algorithm.
 * @param VVSlambda Gain for the virtual visual servoing control law, equivalent to the `$$\alpha$$`
 * gain in the Damped Gauss-Newton formulation.
 *
 * The function refines the object pose given at least 3 object points, their corresponding image
 * projections, an initial solution for the rotation and translation vector,
 * as well as the camera intrinsic matrix and the distortion coefficients.
 * The function minimizes the projection error with respect to the rotation and the translation vectors, using a
 * virtual visual servoing (VVS) CITE: Chaumette06 CITE: Marchand16 scheme.
 */
+ (void)solvePnPRefineVVS:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec criteria:(TermCriteria*)criteria VVSlambda:(double)VVSlambda NS_SWIFT_NAME(solvePnPRefineVVS(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:criteria:VVSlambda:));

/**
 * Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
 * to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel,
 * where N is the number of points. vector\<Point3d\> can also be passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can also be passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Input/Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system. Input values are used as an initial solution.
 * @param tvec Input/Output translation vector. Input values are used as an initial solution.
 * @param criteria Criteria when to stop the Levenberg-Marquard iterative algorithm.
 * gain in the Damped Gauss-Newton formulation.
 *
 * The function refines the object pose given at least 3 object points, their corresponding image
 * projections, an initial solution for the rotation and translation vector,
 * as well as the camera intrinsic matrix and the distortion coefficients.
 * The function minimizes the projection error with respect to the rotation and the translation vectors, using a
 * virtual visual servoing (VVS) CITE: Chaumette06 CITE: Marchand16 scheme.
 */
+ (void)solvePnPRefineVVS:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec criteria:(TermCriteria*)criteria NS_SWIFT_NAME(solvePnPRefineVVS(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:criteria:));

/**
 * Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame
 * to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel,
 * where N is the number of points. vector\<Point3d\> can also be passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can also be passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvec Input/Output rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system. Input values are used as an initial solution.
 * @param tvec Input/Output translation vector. Input values are used as an initial solution.
 * gain in the Damped Gauss-Newton formulation.
 *
 * The function refines the object pose given at least 3 object points, their corresponding image
 * projections, an initial solution for the rotation and translation vector,
 * as well as the camera intrinsic matrix and the distortion coefficients.
 * The function minimizes the projection error with respect to the rotation and the translation vectors, using a
 * virtual visual servoing (VVS) CITE: Chaumette06 CITE: Marchand16 scheme.
 */
+ (void)solvePnPRefineVVS:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec NS_SWIFT_NAME(solvePnPRefineVVS(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:));


//
//  int cv::solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, bool useExtrinsicGuess = false, SolvePnPMethod flags = SOLVEPNP_ITERATIVE, Mat rvec = Mat(), Mat tvec = Mat(), Mat& reprojectionError = Mat())
//
/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param flags Method for solving a PnP problem: see REF: calib3d_solvePnP_flags
 * @param rvec Rotation vector used to initialize an iterative PnP refinement algorithm, when flag is REF: SOLVEPNP_ITERATIVE
 * and useExtrinsicGuess is set to true.
 * @param tvec Translation vector used to initialize an iterative PnP refinement algorithm, when flag is REF: SOLVEPNP_ITERATIVE
 * and useExtrinsicGuess is set to true.
 * @param reprojectionError Optional vector of reprojection error, that is the RMS error
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs useExtrinsicGuess:(BOOL)useExtrinsicGuess flags:(SolvePnPMethod)flags rvec:(Mat*)rvec tvec:(Mat*)tvec reprojectionError:(Mat*)reprojectionError NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:useExtrinsicGuess:flags:rvec:tvec:reprojectionError:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param flags Method for solving a PnP problem: see REF: calib3d_solvePnP_flags
 * @param rvec Rotation vector used to initialize an iterative PnP refinement algorithm, when flag is REF: SOLVEPNP_ITERATIVE
 * and useExtrinsicGuess is set to true.
 * @param tvec Translation vector used to initialize an iterative PnP refinement algorithm, when flag is REF: SOLVEPNP_ITERATIVE
 * and useExtrinsicGuess is set to true.
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs useExtrinsicGuess:(BOOL)useExtrinsicGuess flags:(SolvePnPMethod)flags rvec:(Mat*)rvec tvec:(Mat*)tvec NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:useExtrinsicGuess:flags:rvec:tvec:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param flags Method for solving a PnP problem: see REF: calib3d_solvePnP_flags
 * @param rvec Rotation vector used to initialize an iterative PnP refinement algorithm, when flag is REF: SOLVEPNP_ITERATIVE
 * and useExtrinsicGuess is set to true.
 * and useExtrinsicGuess is set to true.
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs useExtrinsicGuess:(BOOL)useExtrinsicGuess flags:(SolvePnPMethod)flags rvec:(Mat*)rvec NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:useExtrinsicGuess:flags:rvec:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * @param flags Method for solving a PnP problem: see REF: calib3d_solvePnP_flags
 * and useExtrinsicGuess is set to true.
 * and useExtrinsicGuess is set to true.
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs useExtrinsicGuess:(BOOL)useExtrinsicGuess flags:(SolvePnPMethod)flags NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:useExtrinsicGuess:flags:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * @param useExtrinsicGuess Parameter used for #SOLVEPNP_ITERATIVE. If true (1), the function uses
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * and useExtrinsicGuess is set to true.
 * and useExtrinsicGuess is set to true.
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs useExtrinsicGuess:(BOOL)useExtrinsicGuess NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:useExtrinsicGuess:));

/**
 * Finds an object pose from 3D-2D point correspondences.
 *
 * @see `REF: calib3d_solvePnP`
 *
 * This function returns a list of all the possible solutions (a solution is a <rotation vector, translation vector>
 * couple), depending on the number of input points and the chosen method:
 * - P3P methods (REF: SOLVEPNP_P3P, REF: SOLVEPNP_AP3P): 3 or 4 input points. Number of returned solutions can be between 0 and 4 with 3 input points.
 * - REF: SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar. Returns 2 solutions.
 * - REF: SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation.
 * Number of input points must be 4 and 2 solutions are returned. Object points must be defined in the following order:
 *   - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *   - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *   - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *   - point 3: [-squareLength / 2, -squareLength / 2, 0]
 * - for all the other flags, number of input points must be >= 4 and object points can be in any configuration.
 * Only 1 solution is returned.
 *
 * @param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
 * 1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
 * @param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
 * where N is the number of points. vector\<Point2d\> can be also passed here.
 * @param cameraMatrix Input camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param rvecs Vector of output rotation vectors (see REF: Rodrigues ) that, together with tvecs, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvecs Vector of output translation vectors.
 * the provided rvec and tvec values as initial approximations of the rotation and translation
 * vectors, respectively, and further optimizes them.
 * and useExtrinsicGuess is set to true.
 * and useExtrinsicGuess is set to true.
 * (`$$ \text{RMSE} = \sqrt{\frac{\sum_{i}^{N} \left ( \hat{y_i} - y_i \right )^2}{N}} $$`) between the input image points
 * and the 3D object points projected with the estimated pose.
 *
 * More information is described in REF: calib3d_solvePnP
 *
 * NOTE:
 *    -   An example of how to use solvePnP for planar augmented reality can be found at
 *         opencv_source_code/samples/python/plane_ar.py
 *    -   If you are using Python:
 *         - Numpy array slices won't work as input because solvePnP requires contiguous
 *         arrays (enforced by the assertion using cv::Mat::checkVector() around line 55 of
 *         modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         - The P3P algorithm requires image points to be in an array of shape (N,1,2) due
 *         to its calling of #undistortPoints (around line 75 of modules/calib3d/src/solvepnp.cpp version 2.4.9)
 *         which requires 2-channel information.
 *         - Thus, given some data D = np.array(...) where D.shape = (N,M), in order to use a subset of
 *         it as, e.g., imagePoints, one must effectively copy it into a new array: imagePoints =
 *         np.ascontiguousarray(D[:,:2]).reshape((N,1,2))
 *    -   The methods REF: SOLVEPNP_DLS and REF: SOLVEPNP_UPNP cannot be used as the current implementations are
 *        unstable and sometimes give completely wrong results. If you pass one of these two
 *        flags, REF: SOLVEPNP_EPNP method will be used instead.
 *    -   The minimum number of points is 4 in the general case. In the case of REF: SOLVEPNP_P3P and REF: SOLVEPNP_AP3P
 *        methods, it is required to use exactly 4 points (the first 3 points are used to estimate all the solutions
 *        of the P3P problem, the last one is used to retain the best solution that minimizes the reprojection error).
 *    -   With REF: SOLVEPNP_ITERATIVE method and `useExtrinsicGuess=true`, the minimum number of points is 3 (3 points
 *        are sufficient to compute a pose but there are up to 4 solutions). The initial solution should be close to the
 *        global solution to converge.
 *    -   With REF: SOLVEPNP_IPPE input points must be >= 4 and object points must be coplanar.
 *    -   With REF: SOLVEPNP_IPPE_SQUARE this is a special case suitable for marker pose estimation.
 *        Number of input points must be 4. Object points must be defined in the following order:
 *          - point 0: [-squareLength / 2,  squareLength / 2, 0]
 *          - point 1: [ squareLength / 2,  squareLength / 2, 0]
 *          - point 2: [ squareLength / 2, -squareLength / 2, 0]
 *          - point 3: [-squareLength / 2, -squareLength / 2, 0]
 */
+ (int)solvePnPGeneric:(Mat*)objectPoints imagePoints:(Mat*)imagePoints cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs NS_SWIFT_NAME(solvePnPGeneric(objectPoints:imagePoints:cameraMatrix:distCoeffs:rvecs:tvecs:));


//
//  Mat cv::initCameraMatrix2D(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, double aspectRatio = 1.0)
//
/**
 * Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
 *
 * @param objectPoints Vector of vectors of the calibration pattern points in the calibration pattern
 * coordinate space. In the old interface all the per-view vectors are concatenated. See
 * #calibrateCamera for details.
 * @param imagePoints Vector of vectors of the projections of the calibration pattern points. In the
 * old interface all the per-view vectors are concatenated.
 * @param imageSize Image size in pixels used to initialize the principal point.
 * @param aspectRatio If it is zero or negative, both `$$f_x$$` and `$$f_y$$` are estimated independently.
 * Otherwise, `$$f_x = f_y * \texttt{aspectRatio}$$` .
 *
 * The function estimates and returns an initial camera intrinsic matrix for the camera calibration process.
 * Currently, the function only supports planar calibration patterns, which are patterns where each
 * object point has z-coordinate =0.
 */
+ (Mat*)initCameraMatrix2D:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize aspectRatio:(double)aspectRatio NS_SWIFT_NAME(initCameraMatrix2D(objectPoints:imagePoints:imageSize:aspectRatio:));

/**
 * Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
 *
 * @param objectPoints Vector of vectors of the calibration pattern points in the calibration pattern
 * coordinate space. In the old interface all the per-view vectors are concatenated. See
 * #calibrateCamera for details.
 * @param imagePoints Vector of vectors of the projections of the calibration pattern points. In the
 * old interface all the per-view vectors are concatenated.
 * @param imageSize Image size in pixels used to initialize the principal point.
 * Otherwise, `$$f_x = f_y * \texttt{aspectRatio}$$` .
 *
 * The function estimates and returns an initial camera intrinsic matrix for the camera calibration process.
 * Currently, the function only supports planar calibration patterns, which are patterns where each
 * object point has z-coordinate =0.
 */
+ (Mat*)initCameraMatrix2D:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize NS_SWIFT_NAME(initCameraMatrix2D(objectPoints:imagePoints:imageSize:));


//
//  bool cv::findChessboardCorners(Mat image, Size patternSize, Mat& corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE)
//
/**
 * Finds the positions of internal corners of the chessboard.
 *
 * @param image Source chessboard view. It must be an 8-bit grayscale or color image.
 * @param patternSize Number of inner corners per a chessboard row and column
 * ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ).
 * @param corners Output array of detected corners.
 * @param flags Various operation flags that can be zero or a combination of the following values:
 * -   REF: CALIB_CB_ADAPTIVE_THRESH Use adaptive thresholding to convert the image to black
 * and white, rather than a fixed threshold level (computed from the average image brightness).
 * -   REF: CALIB_CB_NORMALIZE_IMAGE Normalize the image gamma with equalizeHist before
 * applying fixed or adaptive thresholding.
 * -   REF: CALIB_CB_FILTER_QUADS Use additional criteria (like contour area, perimeter,
 * square-like shape) to filter out false quads extracted at the contour retrieval stage.
 * -   REF: CALIB_CB_FAST_CHECK Run a fast check on the image that looks for chessboard corners,
 * and shortcut the call if none is found. This can drastically speed up the call in the
 * degenerate condition when no chessboard is observed.
 *
 * The function attempts to determine whether the input image is a view of the chessboard pattern and
 * locate the internal chessboard corners. The function returns a non-zero value if all of the corners
 * are found and they are placed in a certain order (row by row, left to right in every row).
 * Otherwise, if the function fails to find all the corners or reorder them, it returns 0. For example,
 * a regular chessboard has 8 x 8 squares and 7 x 7 internal corners, that is, points where the black
 * squares touch each other. The detected coordinates are approximate, and to determine their positions
 * more accurately, the function calls cornerSubPix. You also may use the function cornerSubPix with
 * different parameters if returned coordinates are not accurate enough.
 *
 * Sample usage of detecting and drawing chessboard corners: :
 *
 *     Size patternsize(8,6); //interior number of corners
 *     Mat gray = ....; //source image
 *     vector<Point2f> corners; //this will be filled by the detected corners
 *
 *     //CALIB_CB_FAST_CHECK saves a lot of time on images
 *     //that do not contain any chessboard corners
 *     bool patternfound = findChessboardCorners(gray, patternsize, corners,
 *             CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
 *             + CALIB_CB_FAST_CHECK);
 *
 *     if(patternfound)
 *       cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
 *         TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
 *
 *     drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
 *
 * NOTE: The function requires white space (like a square-thick border, the wider the better) around
 * the board to make the detection more robust in various environments. Otherwise, if there is no
 * border and the background is dark, the outer black squares cannot be segmented properly and so the
 * square grouping and ordering algorithm fails.
 *
 * Use gen_pattern.py (REF: tutorial_camera_calibration_pattern) to create checkerboard.
 */
+ (BOOL)findChessboardCorners:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners flags:(int)flags NS_SWIFT_NAME(findChessboardCorners(image:patternSize:corners:flags:));

/**
 * Finds the positions of internal corners of the chessboard.
 *
 * @param image Source chessboard view. It must be an 8-bit grayscale or color image.
 * @param patternSize Number of inner corners per a chessboard row and column
 * ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ).
 * @param corners Output array of detected corners.
 * -   REF: CALIB_CB_ADAPTIVE_THRESH Use adaptive thresholding to convert the image to black
 * and white, rather than a fixed threshold level (computed from the average image brightness).
 * -   REF: CALIB_CB_NORMALIZE_IMAGE Normalize the image gamma with equalizeHist before
 * applying fixed or adaptive thresholding.
 * -   REF: CALIB_CB_FILTER_QUADS Use additional criteria (like contour area, perimeter,
 * square-like shape) to filter out false quads extracted at the contour retrieval stage.
 * -   REF: CALIB_CB_FAST_CHECK Run a fast check on the image that looks for chessboard corners,
 * and shortcut the call if none is found. This can drastically speed up the call in the
 * degenerate condition when no chessboard is observed.
 *
 * The function attempts to determine whether the input image is a view of the chessboard pattern and
 * locate the internal chessboard corners. The function returns a non-zero value if all of the corners
 * are found and they are placed in a certain order (row by row, left to right in every row).
 * Otherwise, if the function fails to find all the corners or reorder them, it returns 0. For example,
 * a regular chessboard has 8 x 8 squares and 7 x 7 internal corners, that is, points where the black
 * squares touch each other. The detected coordinates are approximate, and to determine their positions
 * more accurately, the function calls cornerSubPix. You also may use the function cornerSubPix with
 * different parameters if returned coordinates are not accurate enough.
 *
 * Sample usage of detecting and drawing chessboard corners: :
 *
 *     Size patternsize(8,6); //interior number of corners
 *     Mat gray = ....; //source image
 *     vector<Point2f> corners; //this will be filled by the detected corners
 *
 *     //CALIB_CB_FAST_CHECK saves a lot of time on images
 *     //that do not contain any chessboard corners
 *     bool patternfound = findChessboardCorners(gray, patternsize, corners,
 *             CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
 *             + CALIB_CB_FAST_CHECK);
 *
 *     if(patternfound)
 *       cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
 *         TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
 *
 *     drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
 *
 * NOTE: The function requires white space (like a square-thick border, the wider the better) around
 * the board to make the detection more robust in various environments. Otherwise, if there is no
 * border and the background is dark, the outer black squares cannot be segmented properly and so the
 * square grouping and ordering algorithm fails.
 *
 * Use gen_pattern.py (REF: tutorial_camera_calibration_pattern) to create checkerboard.
 */
+ (BOOL)findChessboardCorners:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners NS_SWIFT_NAME(findChessboardCorners(image:patternSize:corners:));


//
//  bool cv::checkChessboard(Mat img, Size size)
//
+ (BOOL)checkChessboard:(Mat*)img size:(Size2i*)size NS_SWIFT_NAME(checkChessboard(img:size:));


//
//  bool cv::findChessboardCornersSB(Mat image, Size patternSize, Mat& corners, int flags, Mat& meta)
//
/**
 * Finds the positions of internal corners of the chessboard using a sector based approach.
 *
 * @param image Source chessboard view. It must be an 8-bit grayscale or color image.
 * @param patternSize Number of inner corners per a chessboard row and column
 * ( patternSize = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ).
 * @param corners Output array of detected corners.
 * @param flags Various operation flags that can be zero or a combination of the following values:
 * -   REF: CALIB_CB_NORMALIZE_IMAGE Normalize the image gamma with equalizeHist before detection.
 * -   REF: CALIB_CB_EXHAUSTIVE Run an exhaustive search to improve detection rate.
 * -   REF: CALIB_CB_ACCURACY Up sample input image to improve sub-pixel accuracy due to aliasing effects.
 * -   REF: CALIB_CB_LARGER The detected pattern is allowed to be larger than patternSize (see description).
 * -   REF: CALIB_CB_MARKER The detected pattern must have a marker (see description).
 * This should be used if an accurate camera calibration is required.
 * @param meta Optional output arrray of detected corners (CV_8UC1 and size = cv::Size(columns,rows)).
 * Each entry stands for one corner of the pattern and can have one of the following values:
 * -   0 = no meta data attached
 * -   1 = left-top corner of a black cell
 * -   2 = left-top corner of a white cell
 * -   3 = left-top corner of a black cell with a white marker dot
 * -   4 = left-top corner of a white cell with a black marker dot (pattern origin in case of markers otherwise first corner)
 *
 * The function is analog to #findChessboardCorners but uses a localized radon
 * transformation approximated by box filters being more robust to all sort of
 * noise, faster on larger images and is able to directly return the sub-pixel
 * position of the internal chessboard corners. The Method is based on the paper
 * CITE: duda2018 "Accurate Detection and Localization of Checkerboard Corners for
 * Calibration" demonstrating that the returned sub-pixel positions are more
 * accurate than the one returned by cornerSubPix allowing a precise camera
 * calibration for demanding applications.
 *
 * In the case, the flags REF: CALIB_CB_LARGER or REF: CALIB_CB_MARKER are given,
 * the result can be recovered from the optional meta array. Both flags are
 * helpful to use calibration patterns exceeding the field of view of the camera.
 * These oversized patterns allow more accurate calibrations as corners can be
 * utilized, which are as close as possible to the image borders.  For a
 * consistent coordinate system across all images, the optional marker (see image
 * below) can be used to move the origin of the board to the location where the
 * black circle is located.
 *
 * NOTE: The function requires a white boarder with roughly the same width as one
 * of the checkerboard fields around the whole board to improve the detection in
 * various environments. In addition, because of the localized radon
 * transformation it is beneficial to use round corners for the field corners
 * which are located on the outside of the board. The following figure illustrates
 * a sample checkerboard optimized for the detection. However, any other checkerboard
 * can be used as well.
 *
 * Use gen_pattern.py (REF: tutorial_camera_calibration_pattern) to create checkerboard.
 * ![Checkerboard](pics/checkerboard_radon.png)
 */
+ (BOOL)findChessboardCornersSBWithMeta:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners flags:(int)flags meta:(Mat*)meta NS_SWIFT_NAME(findChessboardCornersSB(image:patternSize:corners:flags:meta:));


//
//  bool cv::findChessboardCornersSB(Mat image, Size patternSize, Mat& corners, int flags = 0)
//
+ (BOOL)findChessboardCornersSB:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners flags:(int)flags NS_SWIFT_NAME(findChessboardCornersSB(image:patternSize:corners:flags:));

+ (BOOL)findChessboardCornersSB:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners NS_SWIFT_NAME(findChessboardCornersSB(image:patternSize:corners:));


//
//  Scalar cv::estimateChessboardSharpness(Mat image, Size patternSize, Mat corners, float rise_distance = 0.8F, bool vertical = false, Mat& sharpness = Mat())
//
/**
 * Estimates the sharpness of a detected chessboard.
 *
 * Image sharpness, as well as brightness, are a critical parameter for accuracte
 * camera calibration. For accessing these parameters for filtering out
 * problematic calibraiton images, this method calculates edge profiles by traveling from
 * black to white chessboard cell centers. Based on this, the number of pixels is
 * calculated required to transit from black to white. This width of the
 * transition area is a good indication of how sharp the chessboard is imaged
 * and should be below ~3.0 pixels.
 *
 * @param image Gray image used to find chessboard corners
 * @param patternSize Size of a found chessboard pattern
 * @param corners Corners found by #findChessboardCornersSB
 * @param rise_distance Rise distance 0.8 means 10% ... 90% of the final signal strength
 * @param vertical By default edge responses for horizontal lines are calculated
 * @param sharpness Optional output array with a sharpness value for calculated edge responses (see description)
 *
 * The optional sharpness array is of type CV_32FC1 and has for each calculated
 * profile one row with the following five entries:
 * 0 = x coordinate of the underlying edge in the image
 * 1 = y coordinate of the underlying edge in the image
 * 2 = width of the transition area (sharpness)
 * 3 = signal strength in the black cell (min brightness)
 * 4 = signal strength in the white cell (max brightness)
 *
 * @return Scalar(average sharpness, average min brightness, average max brightness,0)
 */
+ (Scalar*)estimateChessboardSharpness:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners rise_distance:(float)rise_distance vertical:(BOOL)vertical sharpness:(Mat*)sharpness NS_SWIFT_NAME(estimateChessboardSharpness(image:patternSize:corners:rise_distance:vertical:sharpness:));

/**
 * Estimates the sharpness of a detected chessboard.
 *
 * Image sharpness, as well as brightness, are a critical parameter for accuracte
 * camera calibration. For accessing these parameters for filtering out
 * problematic calibraiton images, this method calculates edge profiles by traveling from
 * black to white chessboard cell centers. Based on this, the number of pixels is
 * calculated required to transit from black to white. This width of the
 * transition area is a good indication of how sharp the chessboard is imaged
 * and should be below ~3.0 pixels.
 *
 * @param image Gray image used to find chessboard corners
 * @param patternSize Size of a found chessboard pattern
 * @param corners Corners found by #findChessboardCornersSB
 * @param rise_distance Rise distance 0.8 means 10% ... 90% of the final signal strength
 * @param vertical By default edge responses for horizontal lines are calculated
 *
 * The optional sharpness array is of type CV_32FC1 and has for each calculated
 * profile one row with the following five entries:
 * 0 = x coordinate of the underlying edge in the image
 * 1 = y coordinate of the underlying edge in the image
 * 2 = width of the transition area (sharpness)
 * 3 = signal strength in the black cell (min brightness)
 * 4 = signal strength in the white cell (max brightness)
 *
 * @return Scalar(average sharpness, average min brightness, average max brightness,0)
 */
+ (Scalar*)estimateChessboardSharpness:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners rise_distance:(float)rise_distance vertical:(BOOL)vertical NS_SWIFT_NAME(estimateChessboardSharpness(image:patternSize:corners:rise_distance:vertical:));

/**
 * Estimates the sharpness of a detected chessboard.
 *
 * Image sharpness, as well as brightness, are a critical parameter for accuracte
 * camera calibration. For accessing these parameters for filtering out
 * problematic calibraiton images, this method calculates edge profiles by traveling from
 * black to white chessboard cell centers. Based on this, the number of pixels is
 * calculated required to transit from black to white. This width of the
 * transition area is a good indication of how sharp the chessboard is imaged
 * and should be below ~3.0 pixels.
 *
 * @param image Gray image used to find chessboard corners
 * @param patternSize Size of a found chessboard pattern
 * @param corners Corners found by #findChessboardCornersSB
 * @param rise_distance Rise distance 0.8 means 10% ... 90% of the final signal strength
 *
 * The optional sharpness array is of type CV_32FC1 and has for each calculated
 * profile one row with the following five entries:
 * 0 = x coordinate of the underlying edge in the image
 * 1 = y coordinate of the underlying edge in the image
 * 2 = width of the transition area (sharpness)
 * 3 = signal strength in the black cell (min brightness)
 * 4 = signal strength in the white cell (max brightness)
 *
 * @return Scalar(average sharpness, average min brightness, average max brightness,0)
 */
+ (Scalar*)estimateChessboardSharpness:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners rise_distance:(float)rise_distance NS_SWIFT_NAME(estimateChessboardSharpness(image:patternSize:corners:rise_distance:));

/**
 * Estimates the sharpness of a detected chessboard.
 *
 * Image sharpness, as well as brightness, are a critical parameter for accuracte
 * camera calibration. For accessing these parameters for filtering out
 * problematic calibraiton images, this method calculates edge profiles by traveling from
 * black to white chessboard cell centers. Based on this, the number of pixels is
 * calculated required to transit from black to white. This width of the
 * transition area is a good indication of how sharp the chessboard is imaged
 * and should be below ~3.0 pixels.
 *
 * @param image Gray image used to find chessboard corners
 * @param patternSize Size of a found chessboard pattern
 * @param corners Corners found by #findChessboardCornersSB
 *
 * The optional sharpness array is of type CV_32FC1 and has for each calculated
 * profile one row with the following five entries:
 * 0 = x coordinate of the underlying edge in the image
 * 1 = y coordinate of the underlying edge in the image
 * 2 = width of the transition area (sharpness)
 * 3 = signal strength in the black cell (min brightness)
 * 4 = signal strength in the white cell (max brightness)
 *
 * @return Scalar(average sharpness, average min brightness, average max brightness,0)
 */
+ (Scalar*)estimateChessboardSharpness:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners NS_SWIFT_NAME(estimateChessboardSharpness(image:patternSize:corners:));


//
//  bool cv::find4QuadCornerSubpix(Mat img, Mat& corners, Size region_size)
//
+ (BOOL)find4QuadCornerSubpix:(Mat*)img corners:(Mat*)corners region_size:(Size2i*)region_size NS_SWIFT_NAME(find4QuadCornerSubpix(img:corners:region_size:));


//
//  void cv::drawChessboardCorners(Mat& image, Size patternSize, Mat corners, bool patternWasFound)
//
/**
 * Renders the detected chessboard corners.
 *
 * @param image Destination image. It must be an 8-bit color image.
 * @param patternSize Number of inner corners per a chessboard row and column
 * (patternSize = cv::Size(points_per_row,points_per_column)).
 * @param corners Array of detected corners, the output of #findChessboardCorners.
 * @param patternWasFound Parameter indicating whether the complete board was found or not. The
 * return value of #findChessboardCorners should be passed here.
 *
 * The function draws individual chessboard corners detected either as red circles if the board was not
 * found, or as colored corners connected with lines if the board was found.
 */
+ (void)drawChessboardCorners:(Mat*)image patternSize:(Size2i*)patternSize corners:(Mat*)corners patternWasFound:(BOOL)patternWasFound NS_SWIFT_NAME(drawChessboardCorners(image:patternSize:corners:patternWasFound:));


//
//  void cv::drawFrameAxes(Mat& image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness = 3)
//
/**
 * Draw axes of the world/object coordinate system from pose estimation. @see `+solvePnP:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:flags:`
 *
 * @param image Input/output image. It must have 1 or 3 channels. The number of channels is not altered.
 * @param cameraMatrix Input 3x3 floating-point matrix of camera intrinsic parameters.
 * `$$\cameramatrix{A}$$`
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is empty, the zero distortion coefficients are assumed.
 * @param rvec Rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Translation vector.
 * @param length Length of the painted axes in the same unit than tvec (usually in meters).
 * @param thickness Line thickness of the painted axes.
 *
 * This function draws the axes of the world/object coordinate system w.r.t. to the camera frame.
 * OX is drawn in red, OY in green and OZ in blue.
 */
+ (void)drawFrameAxes:(Mat*)image cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec length:(float)length thickness:(int)thickness NS_SWIFT_NAME(drawFrameAxes(image:cameraMatrix:distCoeffs:rvec:tvec:length:thickness:));

/**
 * Draw axes of the world/object coordinate system from pose estimation. @see `+solvePnP:imagePoints:cameraMatrix:distCoeffs:rvec:tvec:useExtrinsicGuess:flags:`
 *
 * @param image Input/output image. It must have 1 or 3 channels. The number of channels is not altered.
 * @param cameraMatrix Input 3x3 floating-point matrix of camera intrinsic parameters.
 * `$$\cameramatrix{A}$$`
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is empty, the zero distortion coefficients are assumed.
 * @param rvec Rotation vector (see REF: Rodrigues ) that, together with tvec, brings points from
 * the model coordinate system to the camera coordinate system.
 * @param tvec Translation vector.
 * @param length Length of the painted axes in the same unit than tvec (usually in meters).
 *
 * This function draws the axes of the world/object coordinate system w.r.t. to the camera frame.
 * OX is drawn in red, OY in green and OZ in blue.
 */
+ (void)drawFrameAxes:(Mat*)image cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvec:(Mat*)rvec tvec:(Mat*)tvec length:(float)length NS_SWIFT_NAME(drawFrameAxes(image:cameraMatrix:distCoeffs:rvec:tvec:length:));


//
//  bool cv::findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags,  _hidden_  blobDetector = cv::SimpleBlobDetector::create(), CirclesGridFinderParameters parameters)
//
/**
 * Finds centers in the grid of circles.
 *
 * @param image grid view of input circles; it must be an 8-bit grayscale or color image.
 * @param patternSize number of circles per row and column
 * ( patternSize = Size(points_per_row, points_per_colum) ).
 * @param centers output array of detected centers.
 * @param flags various operation flags that can be one of the following values:
 * -   REF: CALIB_CB_SYMMETRIC_GRID uses symmetric pattern of circles.
 * -   REF: CALIB_CB_ASYMMETRIC_GRID uses asymmetric pattern of circles.
 * -   REF: CALIB_CB_CLUSTERING uses a special algorithm for grid detection. It is more robust to
 * perspective distortions but much more sensitive to background clutter.
 * @param blobDetector feature detector that finds blobs like dark circles on light background.
 *                     If `blobDetector` is NULL then `image` represents Point2f array of candidates.
 * @param parameters struct for finding circles in a grid pattern.
 *
 * The function attempts to determine whether the input image contains a grid of circles. If it is, the
 * function locates centers of the circles. The function returns a non-zero value if all of the centers
 * have been found and they have been placed in a certain order (row by row, left to right in every
 * row). Otherwise, if the function fails to find all the corners or reorder them, it returns 0.
 *
 * Sample usage of detecting and drawing the centers of circles: :
 *
 *     Size patternsize(7,7); //number of centers
 *     Mat gray = ...; //source image
 *     vector<Point2f> centers; //this will be filled by the detected centers
 *
 *     bool patternfound = findCirclesGrid(gray, patternsize, centers);
 *
 *     drawChessboardCorners(img, patternsize, Mat(centers), patternfound);
 *
 * NOTE: The function requires white space (like a square-thick border, the wider the better) around
 * the board to make the detection more robust in various environments.
 */
+ (BOOL)findCirclesGrid:(Mat*)image patternSize:(Size2i*)patternSize centers:(Mat*)centers flags:(int)flags parameters:(CirclesGridFinderParameters*)parameters NS_SWIFT_NAME(findCirclesGrid(image:patternSize:centers:flags:parameters:));


//
//  bool cv::findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID,  _hidden_  blobDetector = cv::SimpleBlobDetector::create())
//
+ (BOOL)findCirclesGrid:(Mat*)image patternSize:(Size2i*)patternSize centers:(Mat*)centers flags:(int)flags NS_SWIFT_NAME(findCirclesGrid(image:patternSize:centers:flags:));

+ (BOOL)findCirclesGrid:(Mat*)image patternSize:(Size2i*)patternSize centers:(Mat*)centers NS_SWIFT_NAME(findCirclesGrid(image:patternSize:centers:));


//
//  double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration
 * pattern.
 *
 * @param objectPoints In the new interface it is a vector of vectors of calibration pattern points in
 * the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer
 * vector contains as many elements as the number of pattern views. If the same calibration pattern
 * is shown in each view and it is fully visible, all the vectors will be the same. Although, it is
 * possible to use partially occluded patterns or even different patterns in different views. Then,
 * the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's
 * XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig.
 * In the old interface all the vectors of object points from different views are concatenated
 * together.
 * @param imagePoints In the new interface it is a vector of vectors of the projections of calibration
 * pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and
 * objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal,
 * respectively. In the old interface all the vectors of object points from different views are
 * concatenated together.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrix.
 * @param cameraMatrix Input/output 3x3 floating-point camera intrinsic matrix
 * `$$\cameramatrix{A}$$` . If REF: CALIB_USE_INTRINSIC_GUESS
 * and/or REF: CALIB_FIX_ASPECT_RATIO, REF: CALIB_FIX_PRINCIPAL_POINT or REF: CALIB_FIX_FOCAL_LENGTH
 * are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
 * @param distCoeffs Input/output vector of distortion coefficients
 * `$$\distcoeffs$$`.
 * @param rvecs Output vector of rotation vectors (REF: Rodrigues ) estimated for each pattern view
 * (e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding
 * i-th translation vector (see the next output parameter description) brings the calibration pattern
 * from the object coordinate space (in which object points are specified) to the camera coordinate
 * space. In more technical terms, the tuple of the i-th rotation and translation vector performs
 * a change of basis from object coordinate space to camera coordinate space. Due to its duality, this
 * tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate
 * space.
 * @param tvecs Output vector of translation vectors estimated for each pattern view, see parameter
 * describtion above.
 * @param 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.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic
 * parameters. Order of deviations values: `$$(R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})$$` where M is
 * the number of pattern views. `$$R_i, T_i$$` are concatenated 1x3 vectors.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 * -   REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of
 * fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 * center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 * Note, that if intrinsic parameters are known, there is no need to use this function just to
 * estimate extrinsic parameters. Use REF: solvePnP instead.
 * -   REF: CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when
 *  REF: CALIB_USE_INTRINSIC_GUESS is set too.
 * -   REF: CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The
 * ratio fx/fy stays the same as in the input cameraMatrix . When
 *  REF: CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are
 * ignored, only their ratio is computed and used further.
 * -   REF: CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients `$$(p_1, p_2)$$` are set
 * to zeros and stay zero.
 * -   REF: CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if
 *  REF: CALIB_USE_INTRINSIC_GUESS is set.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 The corresponding radial distortion
 * coefficient is not changed during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is
 * set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the rational model and return 8 coefficients or more.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients or more.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * @param criteria Termination criteria for the iterative optimization algorithm.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000 and CITE: BouguetMCT . The coordinates of 3D object
 * points and their corresponding 2D projections in each view must be specified. That may be achieved
 * by using an object with known geometry and easily detectable feature points. Such an object is
 * called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as
 * a calibration rig (see REF: findChessboardCorners). Currently, initialization of intrinsic
 * parameters (when REF: CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration
 * patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also
 * be used as long as initial cameraMatrix is provided.
 *
 * The algorithm performs the following steps:
 *
 * -   Compute the initial intrinsic parameters (the option only available for planar calibration
 *     patterns) or read them from the input parameters. The distortion coefficients are all set to
 *     zeros initially unless some of CALIB_FIX_K? are specified.
 *
 * -   Estimate the initial camera pose as if the intrinsic parameters have been already known. This is
 *     done using REF: solvePnP .
 *
 * -   Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error,
 *     that is, the total sum of squared distances between the observed feature points imagePoints and
 *     the projected (using the current estimates for camera parameters and the poses) object points
 *     objectPoints. See REF: projectPoints for details.
 *
 * NOTE:
 *     If you use a non-square (i.e. non-N-by-N) grid and REF: findChessboardCorners for calibration,
 *     and REF: calibrateCamera returns bad values (zero distortion coefficients, `$$c_x$$` and
 *     `$$c_y$$` very far from the image center, and/or large differences between `$$f_x$$` and
 *     `$$f_y$$` (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols)
 *     instead of using patternSize=cvSize(cols,rows) in REF: findChessboardCorners.
 *
 * @sa
 *    calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate,
 *    undistort
 */
+ (double)calibrateCameraExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics perViewErrors:(Mat*)perViewErrors flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:stdDeviationsIntrinsics:stdDeviationsExtrinsics:perViewErrors:flags:criteria:));

/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration
 * pattern.
 *
 * @param objectPoints In the new interface it is a vector of vectors of calibration pattern points in
 * the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer
 * vector contains as many elements as the number of pattern views. If the same calibration pattern
 * is shown in each view and it is fully visible, all the vectors will be the same. Although, it is
 * possible to use partially occluded patterns or even different patterns in different views. Then,
 * the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's
 * XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig.
 * In the old interface all the vectors of object points from different views are concatenated
 * together.
 * @param imagePoints In the new interface it is a vector of vectors of the projections of calibration
 * pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and
 * objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal,
 * respectively. In the old interface all the vectors of object points from different views are
 * concatenated together.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrix.
 * @param cameraMatrix Input/output 3x3 floating-point camera intrinsic matrix
 * `$$\cameramatrix{A}$$` . If REF: CALIB_USE_INTRINSIC_GUESS
 * and/or REF: CALIB_FIX_ASPECT_RATIO, REF: CALIB_FIX_PRINCIPAL_POINT or REF: CALIB_FIX_FOCAL_LENGTH
 * are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
 * @param distCoeffs Input/output vector of distortion coefficients
 * `$$\distcoeffs$$`.
 * @param rvecs Output vector of rotation vectors (REF: Rodrigues ) estimated for each pattern view
 * (e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding
 * i-th translation vector (see the next output parameter description) brings the calibration pattern
 * from the object coordinate space (in which object points are specified) to the camera coordinate
 * space. In more technical terms, the tuple of the i-th rotation and translation vector performs
 * a change of basis from object coordinate space to camera coordinate space. Due to its duality, this
 * tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate
 * space.
 * @param tvecs Output vector of translation vectors estimated for each pattern view, see parameter
 * describtion above.
 * @param 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.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic
 * parameters. Order of deviations values: `$$(R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})$$` where M is
 * the number of pattern views. `$$R_i, T_i$$` are concatenated 1x3 vectors.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 * -   REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of
 * fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 * center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 * Note, that if intrinsic parameters are known, there is no need to use this function just to
 * estimate extrinsic parameters. Use REF: solvePnP instead.
 * -   REF: CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when
 *  REF: CALIB_USE_INTRINSIC_GUESS is set too.
 * -   REF: CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The
 * ratio fx/fy stays the same as in the input cameraMatrix . When
 *  REF: CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are
 * ignored, only their ratio is computed and used further.
 * -   REF: CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients `$$(p_1, p_2)$$` are set
 * to zeros and stay zero.
 * -   REF: CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if
 *  REF: CALIB_USE_INTRINSIC_GUESS is set.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 The corresponding radial distortion
 * coefficient is not changed during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is
 * set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the rational model and return 8 coefficients or more.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients or more.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000 and CITE: BouguetMCT . The coordinates of 3D object
 * points and their corresponding 2D projections in each view must be specified. That may be achieved
 * by using an object with known geometry and easily detectable feature points. Such an object is
 * called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as
 * a calibration rig (see REF: findChessboardCorners). Currently, initialization of intrinsic
 * parameters (when REF: CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration
 * patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also
 * be used as long as initial cameraMatrix is provided.
 *
 * The algorithm performs the following steps:
 *
 * -   Compute the initial intrinsic parameters (the option only available for planar calibration
 *     patterns) or read them from the input parameters. The distortion coefficients are all set to
 *     zeros initially unless some of CALIB_FIX_K? are specified.
 *
 * -   Estimate the initial camera pose as if the intrinsic parameters have been already known. This is
 *     done using REF: solvePnP .
 *
 * -   Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error,
 *     that is, the total sum of squared distances between the observed feature points imagePoints and
 *     the projected (using the current estimates for camera parameters and the poses) object points
 *     objectPoints. See REF: projectPoints for details.
 *
 * NOTE:
 *     If you use a non-square (i.e. non-N-by-N) grid and REF: findChessboardCorners for calibration,
 *     and REF: calibrateCamera returns bad values (zero distortion coefficients, `$$c_x$$` and
 *     `$$c_y$$` very far from the image center, and/or large differences between `$$f_x$$` and
 *     `$$f_y$$` (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols)
 *     instead of using patternSize=cvSize(cols,rows) in REF: findChessboardCorners.
 *
 * @sa
 *    calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate,
 *    undistort
 */
+ (double)calibrateCameraExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics perViewErrors:(Mat*)perViewErrors flags:(int)flags NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:stdDeviationsIntrinsics:stdDeviationsExtrinsics:perViewErrors:flags:));

/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration
 * pattern.
 *
 * @param objectPoints In the new interface it is a vector of vectors of calibration pattern points in
 * the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer
 * vector contains as many elements as the number of pattern views. If the same calibration pattern
 * is shown in each view and it is fully visible, all the vectors will be the same. Although, it is
 * possible to use partially occluded patterns or even different patterns in different views. Then,
 * the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's
 * XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig.
 * In the old interface all the vectors of object points from different views are concatenated
 * together.
 * @param imagePoints In the new interface it is a vector of vectors of the projections of calibration
 * pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and
 * objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal,
 * respectively. In the old interface all the vectors of object points from different views are
 * concatenated together.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrix.
 * @param cameraMatrix Input/output 3x3 floating-point camera intrinsic matrix
 * `$$\cameramatrix{A}$$` . If REF: CALIB_USE_INTRINSIC_GUESS
 * and/or REF: CALIB_FIX_ASPECT_RATIO, REF: CALIB_FIX_PRINCIPAL_POINT or REF: CALIB_FIX_FOCAL_LENGTH
 * are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
 * @param distCoeffs Input/output vector of distortion coefficients
 * `$$\distcoeffs$$`.
 * @param rvecs Output vector of rotation vectors (REF: Rodrigues ) estimated for each pattern view
 * (e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding
 * i-th translation vector (see the next output parameter description) brings the calibration pattern
 * from the object coordinate space (in which object points are specified) to the camera coordinate
 * space. In more technical terms, the tuple of the i-th rotation and translation vector performs
 * a change of basis from object coordinate space to camera coordinate space. Due to its duality, this
 * tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate
 * space.
 * @param tvecs Output vector of translation vectors estimated for each pattern view, see parameter
 * describtion above.
 * @param 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.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic
 * parameters. Order of deviations values: `$$(R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})$$` where M is
 * the number of pattern views. `$$R_i, T_i$$` are concatenated 1x3 vectors.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * -   REF: CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of
 * fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 * center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 * Note, that if intrinsic parameters are known, there is no need to use this function just to
 * estimate extrinsic parameters. Use REF: solvePnP instead.
 * -   REF: CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when
 *  REF: CALIB_USE_INTRINSIC_GUESS is set too.
 * -   REF: CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The
 * ratio fx/fy stays the same as in the input cameraMatrix . When
 *  REF: CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are
 * ignored, only their ratio is computed and used further.
 * -   REF: CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients `$$(p_1, p_2)$$` are set
 * to zeros and stay zero.
 * -   REF: CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if
 *  REF: CALIB_USE_INTRINSIC_GUESS is set.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 The corresponding radial distortion
 * coefficient is not changed during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is
 * set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the rational model and return 8 coefficients or more.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients or more.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000 and CITE: BouguetMCT . The coordinates of 3D object
 * points and their corresponding 2D projections in each view must be specified. That may be achieved
 * by using an object with known geometry and easily detectable feature points. Such an object is
 * called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as
 * a calibration rig (see REF: findChessboardCorners). Currently, initialization of intrinsic
 * parameters (when REF: CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration
 * patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also
 * be used as long as initial cameraMatrix is provided.
 *
 * The algorithm performs the following steps:
 *
 * -   Compute the initial intrinsic parameters (the option only available for planar calibration
 *     patterns) or read them from the input parameters. The distortion coefficients are all set to
 *     zeros initially unless some of CALIB_FIX_K? are specified.
 *
 * -   Estimate the initial camera pose as if the intrinsic parameters have been already known. This is
 *     done using REF: solvePnP .
 *
 * -   Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error,
 *     that is, the total sum of squared distances between the observed feature points imagePoints and
 *     the projected (using the current estimates for camera parameters and the poses) object points
 *     objectPoints. See REF: projectPoints for details.
 *
 * NOTE:
 *     If you use a non-square (i.e. non-N-by-N) grid and REF: findChessboardCorners for calibration,
 *     and REF: calibrateCamera returns bad values (zero distortion coefficients, `$$c_x$$` and
 *     `$$c_y$$` very far from the image center, and/or large differences between `$$f_x$$` and
 *     `$$f_y$$` (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols)
 *     instead of using patternSize=cvSize(cols,rows) in REF: findChessboardCorners.
 *
 * @sa
 *    calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate,
 *    undistort
 */
+ (double)calibrateCameraExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics perViewErrors:(Mat*)perViewErrors NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:stdDeviationsIntrinsics:stdDeviationsExtrinsics:perViewErrors:));


//
//  double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
+ (double)calibrateCamera:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:flags:criteria:));

+ (double)calibrateCamera:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs flags:(int)flags NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:flags:));

+ (double)calibrateCamera:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs NS_SWIFT_NAME(calibrateCamera(objectPoints:imagePoints:imageSize:cameraMatrix:distCoeffs:rvecs:tvecs:));


//
//  double cv::calibrateCameraRO(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, int iFixedPoint, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& newObjPoints, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& stdDeviationsObjPoints, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 *
 * This function is an extension of #calibrateCamera with the method of releasing object which was
 * proposed in CITE: strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar
 * targets (calibration plates), this method can dramatically improve the precision of the estimated
 * camera parameters. Both the object-releasing method and standard method are supported by this
 * function. Use the parameter **iFixedPoint** for method selection. In the internal implementation,
 * #calibrateCamera is a wrapper for this function.
 *
 * @param objectPoints Vector of vectors of calibration pattern points in the calibration pattern
 * coordinate space. See #calibrateCamera for details. If the method of releasing object to be used,
 * the identical calibration board must be used in each view and it must be fully visible, and all
 * objectPoints[i] must be the same and all points should be roughly close to a plane. **The calibration
 * target has to be rigid, or at least static if the camera (rather than the calibration target) is
 * shifted for grabbing images.**
 * @param imagePoints Vector of vectors of the projections of calibration pattern points. See
 * #calibrateCamera for details.
 * @param imageSize Size of the image used only to initialize the intrinsic camera matrix.
 * @param iFixedPoint The index of the 3D object point in objectPoints[0] to be fixed. It also acts as
 * a switch for calibration method selection. If object-releasing method to be used, pass in the
 * parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will
 * make standard calibration method selected. Usually the top-right corner point of the calibration
 * board grid is recommended to be fixed when object-releasing method being utilized. According to
 * \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front
 * and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and
 * newObjPoints are only possible if coordinates of these three fixed points are accurate enough.
 * @param cameraMatrix Output 3x3 floating-point camera matrix. See #calibrateCamera for details.
 * @param distCoeffs Output vector of distortion coefficients. See #calibrateCamera for details.
 * @param rvecs Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera
 * for details.
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 * @param newObjPoints The updated output vector of calibration pattern points. The coordinates might
 * be scaled based on three fixed points. The returned coordinates are accurate only if the above
 * mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter
 * is ignored with standard calibration method.
 * @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsObjPoints Output vector of standard deviations estimated for refined coordinates
 * of calibration pattern points. It has the same size and order as objectPoints[0] vector. This
 * parameter is ignored with standard calibration method.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of some predefined values. See
 * #calibrateCamera for details. If the method of releasing object is used, the calibration time may
 * be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially
 * less precise and less stable in some rare cases.
 * @param criteria Termination criteria for the iterative optimization algorithm.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000, CITE: BouguetMCT and CITE: strobl2011iccv. See
 * #calibrateCamera for other detailed explanations.
 * @sa
 *    calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
 */
+ (double)calibrateCameraROExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics stdDeviationsObjPoints:(Mat*)stdDeviationsObjPoints perViewErrors:(Mat*)perViewErrors flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:stdDeviationsIntrinsics:stdDeviationsExtrinsics:stdDeviationsObjPoints:perViewErrors:flags:criteria:));

/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 *
 * This function is an extension of #calibrateCamera with the method of releasing object which was
 * proposed in CITE: strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar
 * targets (calibration plates), this method can dramatically improve the precision of the estimated
 * camera parameters. Both the object-releasing method and standard method are supported by this
 * function. Use the parameter **iFixedPoint** for method selection. In the internal implementation,
 * #calibrateCamera is a wrapper for this function.
 *
 * @param objectPoints Vector of vectors of calibration pattern points in the calibration pattern
 * coordinate space. See #calibrateCamera for details. If the method of releasing object to be used,
 * the identical calibration board must be used in each view and it must be fully visible, and all
 * objectPoints[i] must be the same and all points should be roughly close to a plane. **The calibration
 * target has to be rigid, or at least static if the camera (rather than the calibration target) is
 * shifted for grabbing images.**
 * @param imagePoints Vector of vectors of the projections of calibration pattern points. See
 * #calibrateCamera for details.
 * @param imageSize Size of the image used only to initialize the intrinsic camera matrix.
 * @param iFixedPoint The index of the 3D object point in objectPoints[0] to be fixed. It also acts as
 * a switch for calibration method selection. If object-releasing method to be used, pass in the
 * parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will
 * make standard calibration method selected. Usually the top-right corner point of the calibration
 * board grid is recommended to be fixed when object-releasing method being utilized. According to
 * \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front
 * and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and
 * newObjPoints are only possible if coordinates of these three fixed points are accurate enough.
 * @param cameraMatrix Output 3x3 floating-point camera matrix. See #calibrateCamera for details.
 * @param distCoeffs Output vector of distortion coefficients. See #calibrateCamera for details.
 * @param rvecs Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera
 * for details.
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 * @param newObjPoints The updated output vector of calibration pattern points. The coordinates might
 * be scaled based on three fixed points. The returned coordinates are accurate only if the above
 * mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter
 * is ignored with standard calibration method.
 * @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsObjPoints Output vector of standard deviations estimated for refined coordinates
 * of calibration pattern points. It has the same size and order as objectPoints[0] vector. This
 * parameter is ignored with standard calibration method.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of some predefined values. See
 * #calibrateCamera for details. If the method of releasing object is used, the calibration time may
 * be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially
 * less precise and less stable in some rare cases.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000, CITE: BouguetMCT and CITE: strobl2011iccv. See
 * #calibrateCamera for other detailed explanations.
 * @sa
 *    calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
 */
+ (double)calibrateCameraROExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics stdDeviationsObjPoints:(Mat*)stdDeviationsObjPoints perViewErrors:(Mat*)perViewErrors flags:(int)flags NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:stdDeviationsIntrinsics:stdDeviationsExtrinsics:stdDeviationsObjPoints:perViewErrors:flags:));

/**
 * Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 *
 * This function is an extension of #calibrateCamera with the method of releasing object which was
 * proposed in CITE: strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar
 * targets (calibration plates), this method can dramatically improve the precision of the estimated
 * camera parameters. Both the object-releasing method and standard method are supported by this
 * function. Use the parameter **iFixedPoint** for method selection. In the internal implementation,
 * #calibrateCamera is a wrapper for this function.
 *
 * @param objectPoints Vector of vectors of calibration pattern points in the calibration pattern
 * coordinate space. See #calibrateCamera for details. If the method of releasing object to be used,
 * the identical calibration board must be used in each view and it must be fully visible, and all
 * objectPoints[i] must be the same and all points should be roughly close to a plane. **The calibration
 * target has to be rigid, or at least static if the camera (rather than the calibration target) is
 * shifted for grabbing images.**
 * @param imagePoints Vector of vectors of the projections of calibration pattern points. See
 * #calibrateCamera for details.
 * @param imageSize Size of the image used only to initialize the intrinsic camera matrix.
 * @param iFixedPoint The index of the 3D object point in objectPoints[0] to be fixed. It also acts as
 * a switch for calibration method selection. If object-releasing method to be used, pass in the
 * parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will
 * make standard calibration method selected. Usually the top-right corner point of the calibration
 * board grid is recommended to be fixed when object-releasing method being utilized. According to
 * \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front
 * and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and
 * newObjPoints are only possible if coordinates of these three fixed points are accurate enough.
 * @param cameraMatrix Output 3x3 floating-point camera matrix. See #calibrateCamera for details.
 * @param distCoeffs Output vector of distortion coefficients. See #calibrateCamera for details.
 * @param rvecs Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera
 * for details.
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 * @param newObjPoints The updated output vector of calibration pattern points. The coordinates might
 * be scaled based on three fixed points. The returned coordinates are accurate only if the above
 * mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter
 * is ignored with standard calibration method.
 * @param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
 * See #calibrateCamera for details.
 * @param stdDeviationsObjPoints Output vector of standard deviations estimated for refined coordinates
 * of calibration pattern points. It has the same size and order as objectPoints[0] vector. This
 * parameter is ignored with standard calibration method.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * #calibrateCamera for details. If the method of releasing object is used, the calibration time may
 * be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially
 * less precise and less stable in some rare cases.
 *
 * @return the overall RMS re-projection error.
 *
 * The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
 * views. The algorithm is based on CITE: Zhang2000, CITE: BouguetMCT and CITE: strobl2011iccv. See
 * #calibrateCamera for other detailed explanations.
 * @sa
 *    calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
 */
+ (double)calibrateCameraROExtended:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints stdDeviationsIntrinsics:(Mat*)stdDeviationsIntrinsics stdDeviationsExtrinsics:(Mat*)stdDeviationsExtrinsics stdDeviationsObjPoints:(Mat*)stdDeviationsObjPoints perViewErrors:(Mat*)perViewErrors NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:stdDeviationsIntrinsics:stdDeviationsExtrinsics:stdDeviationsObjPoints:perViewErrors:));


//
//  double cv::calibrateCameraRO(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, int iFixedPoint, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& newObjPoints, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
+ (double)calibrateCameraRO:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:flags:criteria:));

+ (double)calibrateCameraRO:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints flags:(int)flags NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:flags:));

+ (double)calibrateCameraRO:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints imageSize:(Size2i*)imageSize iFixedPoint:(int)iFixedPoint cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs newObjPoints:(Mat*)newObjPoints NS_SWIFT_NAME(calibrateCameraRO(objectPoints:imagePoints:imageSize:iFixedPoint:cameraMatrix:distCoeffs:rvecs:tvecs:newObjPoints:));


//
//  void cv::calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio)
//
/**
 * Computes useful camera characteristics from the camera intrinsic matrix.
 *
 * @param cameraMatrix Input camera intrinsic matrix that can be estimated by #calibrateCamera or
 * #stereoCalibrate .
 * @param imageSize Input image size in pixels.
 * @param apertureWidth Physical width in mm of the sensor.
 * @param apertureHeight Physical height in mm of the sensor.
 * @param fovx Output field of view in degrees along the horizontal sensor axis.
 * @param fovy Output field of view in degrees along the vertical sensor axis.
 * @param focalLength Focal length of the lens in mm.
 * @param principalPoint Principal point in mm.
 * @param aspectRatio `$$f_y/f_x$$`
 *
 * The function computes various useful camera characteristics from the previously estimated camera
 * matrix.
 *
 * NOTE:
 *    Do keep in mind that the unity measure 'mm' stands for whatever unit of measure one chooses for
 *     the chessboard pitch (it can thus be any value).
 */
+ (void)calibrationMatrixValues:(Mat*)cameraMatrix imageSize:(Size2i*)imageSize apertureWidth:(double)apertureWidth apertureHeight:(double)apertureHeight fovx:(double*)fovx fovy:(double*)fovy focalLength:(double*)focalLength principalPoint:(Point2d*)principalPoint aspectRatio:(double*)aspectRatio NS_SWIFT_NAME(calibrationMatrixValues(cameraMatrix:imageSize:apertureWidth:apertureHeight:fovx:fovy:focalLength:principalPoint:aspectRatio:));


//
//  double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, Mat& perViewErrors, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
//
/**
 * Calibrates a stereo camera set up. This function finds the intrinsic parameters
 * for each of the two cameras and the extrinsic parameters between the two cameras.
 *
 * @param objectPoints Vector of vectors of the calibration pattern points. The same structure as
 * in REF: calibrateCamera. For each pattern view, both cameras need to see the same object
 * points. Therefore, objectPoints.size(), imagePoints1.size(), and imagePoints2.size() need to be
 * equal as well as objectPoints[i].size(), imagePoints1[i].size(), and imagePoints2[i].size() need to
 * be equal for each i.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 * observed by the first camera. The same structure as in REF: calibrateCamera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 * observed by the second camera. The same structure as in REF: calibrateCamera.
 * @param cameraMatrix1 Input/output camera intrinsic matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output second camera intrinsic matrix for the second camera. See description for
 * cameraMatrix1.
 * @param distCoeffs2 Input/output lens distortion coefficients for the second camera. See
 * description for distCoeffs1.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrices.
 * @param R Output rotation matrix. Together with the translation vector T, this matrix brings
 * points given in the first camera's coordinate system to points in the second camera's
 * coordinate system. In more technical terms, the tuple of R and T performs a change of basis
 * from the first camera's coordinate system to the second camera's coordinate system. Due to its
 * duality, this tuple is equivalent to the position of the first camera with respect to the
 * second camera coordinate system.
 * @param T Output translation vector, see description above.
 * @param E Output essential matrix.
 * @param F Output fundamental matrix.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 * -   REF: CALIB_FIX_INTRINSIC Fix cameraMatrix? and distCoeffs? so that only R, T, E, and F
 * matrices are estimated.
 * -   REF: CALIB_USE_INTRINSIC_GUESS Optimize some or all of the intrinsic parameters
 * according to the specified flags. Initial values are provided by the user.
 * -   REF: CALIB_USE_EXTRINSIC_GUESS R and T contain valid initial values that are optimized further.
 * Otherwise R and T are initialized to the median value of the pattern views (each dimension separately).
 * -   REF: CALIB_FIX_PRINCIPAL_POINT Fix the principal points during the optimization.
 * -   REF: CALIB_FIX_FOCAL_LENGTH Fix `$$f^{(j)}_x$$` and `$$f^{(j)}_y$$` .
 * -   REF: CALIB_FIX_ASPECT_RATIO Optimize `$$f^{(j)}_y$$` . Fix the ratio `$$f^{(j)}_x/f^{(j)}_y$$`
 * .
 * -   REF: CALIB_SAME_FOCAL_LENGTH Enforce `$$f^{(0)}_x=f^{(1)}_x$$` and `$$f^{(0)}_y=f^{(1)}_y$$` .
 * -   REF: CALIB_ZERO_TANGENT_DIST Set tangential distortion coefficients for each camera to
 * zeros and fix there.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 Do not change the corresponding radial
 * distortion coefficient during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set,
 * the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Enable coefficients k4, k5, and k6. To provide the backward
 * compatibility, this extra flag should be explicitly specified to make the calibration
 * function use the rational model and return 8 coefficients. If the flag is not set, the
 * function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * @param criteria Termination criteria for the iterative optimization algorithm.
 *
 * The function estimates the transformation between two cameras making a stereo pair. If one computes
 * the poses of an object relative to the first camera and to the second camera,
 * ( `$$R_1$$`,`$$T_1$$` ) and (`$$R_2$$`,`$$T_2$$`), respectively, for a stereo camera where the
 * relative position and orientation between the two cameras are fixed, then those poses definitely
 * relate to each other. This means, if the relative position and orientation (`$$R$$`,`$$T$$`) of the
 * two cameras is known, it is possible to compute (`$$R_2$$`,`$$T_2$$`) when (`$$R_1$$`,`$$T_1$$`) is
 * given. This is what the described function does. It computes (`$$R$$`,`$$T$$`) such that:
 *
 * `$$R_2=R R_1$$`
 * `$$T_2=R T_1 + T.$$`
 *
 * Therefore, one can compute the coordinate representation of a 3D point for the second camera's
 * coordinate system when given the point's coordinate representation in the first camera's coordinate
 * system:
 *
 * `$$\begin{bmatrix}
 * X_2 \\
 * Y_2 \\
 * Z_2 \\
 * 1
 * \end{bmatrix} = \begin{bmatrix}
 * R & T \\
 * 0 & 1
 * \end{bmatrix} \begin{bmatrix}
 * X_1 \\
 * Y_1 \\
 * Z_1 \\
 * 1
 * \end{bmatrix}.$$`
 *
 *
 * Optionally, it computes the essential matrix E:
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R$$`
 *
 * where `$$T_i$$` are components of the translation vector `$$T$$` : `$$T=[T_0, T_1, T_2]^T$$` .
 * And the function can also compute the fundamental matrix F:
 *
 * `$$F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}$$`
 *
 * Besides the stereo-related information, the function can also perform a full calibration of each of
 * the two cameras. However, due to the high dimensionality of the parameter space and noise in the
 * input data, the function can diverge from the correct solution. If the intrinsic parameters can be
 * estimated with high accuracy for each of the cameras individually (for example, using
 * #calibrateCamera ), you are recommended to do so and then pass REF: CALIB_FIX_INTRINSIC flag to the
 * function along with the computed intrinsic parameters. Otherwise, if all the parameters are
 * estimated at once, it makes sense to restrict some parameters, for example, pass
 *  REF: CALIB_SAME_FOCAL_LENGTH and REF: CALIB_ZERO_TANGENT_DIST flags, which is usually a
 * reasonable assumption.
 *
 * Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
 * points in all the available views from both cameras. The function returns the final value of the
 * re-projection error.
 */
+ (double)stereoCalibrateExtended:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F perViewErrors:(Mat*)perViewErrors flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:perViewErrors:flags:criteria:));

/**
 * Calibrates a stereo camera set up. This function finds the intrinsic parameters
 * for each of the two cameras and the extrinsic parameters between the two cameras.
 *
 * @param objectPoints Vector of vectors of the calibration pattern points. The same structure as
 * in REF: calibrateCamera. For each pattern view, both cameras need to see the same object
 * points. Therefore, objectPoints.size(), imagePoints1.size(), and imagePoints2.size() need to be
 * equal as well as objectPoints[i].size(), imagePoints1[i].size(), and imagePoints2[i].size() need to
 * be equal for each i.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 * observed by the first camera. The same structure as in REF: calibrateCamera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 * observed by the second camera. The same structure as in REF: calibrateCamera.
 * @param cameraMatrix1 Input/output camera intrinsic matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output second camera intrinsic matrix for the second camera. See description for
 * cameraMatrix1.
 * @param distCoeffs2 Input/output lens distortion coefficients for the second camera. See
 * description for distCoeffs1.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrices.
 * @param R Output rotation matrix. Together with the translation vector T, this matrix brings
 * points given in the first camera's coordinate system to points in the second camera's
 * coordinate system. In more technical terms, the tuple of R and T performs a change of basis
 * from the first camera's coordinate system to the second camera's coordinate system. Due to its
 * duality, this tuple is equivalent to the position of the first camera with respect to the
 * second camera coordinate system.
 * @param T Output translation vector, see description above.
 * @param E Output essential matrix.
 * @param F Output fundamental matrix.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 * -   REF: CALIB_FIX_INTRINSIC Fix cameraMatrix? and distCoeffs? so that only R, T, E, and F
 * matrices are estimated.
 * -   REF: CALIB_USE_INTRINSIC_GUESS Optimize some or all of the intrinsic parameters
 * according to the specified flags. Initial values are provided by the user.
 * -   REF: CALIB_USE_EXTRINSIC_GUESS R and T contain valid initial values that are optimized further.
 * Otherwise R and T are initialized to the median value of the pattern views (each dimension separately).
 * -   REF: CALIB_FIX_PRINCIPAL_POINT Fix the principal points during the optimization.
 * -   REF: CALIB_FIX_FOCAL_LENGTH Fix `$$f^{(j)}_x$$` and `$$f^{(j)}_y$$` .
 * -   REF: CALIB_FIX_ASPECT_RATIO Optimize `$$f^{(j)}_y$$` . Fix the ratio `$$f^{(j)}_x/f^{(j)}_y$$`
 * .
 * -   REF: CALIB_SAME_FOCAL_LENGTH Enforce `$$f^{(0)}_x=f^{(1)}_x$$` and `$$f^{(0)}_y=f^{(1)}_y$$` .
 * -   REF: CALIB_ZERO_TANGENT_DIST Set tangential distortion coefficients for each camera to
 * zeros and fix there.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 Do not change the corresponding radial
 * distortion coefficient during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set,
 * the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Enable coefficients k4, k5, and k6. To provide the backward
 * compatibility, this extra flag should be explicitly specified to make the calibration
 * function use the rational model and return 8 coefficients. If the flag is not set, the
 * function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 *
 * The function estimates the transformation between two cameras making a stereo pair. If one computes
 * the poses of an object relative to the first camera and to the second camera,
 * ( `$$R_1$$`,`$$T_1$$` ) and (`$$R_2$$`,`$$T_2$$`), respectively, for a stereo camera where the
 * relative position and orientation between the two cameras are fixed, then those poses definitely
 * relate to each other. This means, if the relative position and orientation (`$$R$$`,`$$T$$`) of the
 * two cameras is known, it is possible to compute (`$$R_2$$`,`$$T_2$$`) when (`$$R_1$$`,`$$T_1$$`) is
 * given. This is what the described function does. It computes (`$$R$$`,`$$T$$`) such that:
 *
 * `$$R_2=R R_1$$`
 * `$$T_2=R T_1 + T.$$`
 *
 * Therefore, one can compute the coordinate representation of a 3D point for the second camera's
 * coordinate system when given the point's coordinate representation in the first camera's coordinate
 * system:
 *
 * `$$\begin{bmatrix}
 * X_2 \\
 * Y_2 \\
 * Z_2 \\
 * 1
 * \end{bmatrix} = \begin{bmatrix}
 * R & T \\
 * 0 & 1
 * \end{bmatrix} \begin{bmatrix}
 * X_1 \\
 * Y_1 \\
 * Z_1 \\
 * 1
 * \end{bmatrix}.$$`
 *
 *
 * Optionally, it computes the essential matrix E:
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R$$`
 *
 * where `$$T_i$$` are components of the translation vector `$$T$$` : `$$T=[T_0, T_1, T_2]^T$$` .
 * And the function can also compute the fundamental matrix F:
 *
 * `$$F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}$$`
 *
 * Besides the stereo-related information, the function can also perform a full calibration of each of
 * the two cameras. However, due to the high dimensionality of the parameter space and noise in the
 * input data, the function can diverge from the correct solution. If the intrinsic parameters can be
 * estimated with high accuracy for each of the cameras individually (for example, using
 * #calibrateCamera ), you are recommended to do so and then pass REF: CALIB_FIX_INTRINSIC flag to the
 * function along with the computed intrinsic parameters. Otherwise, if all the parameters are
 * estimated at once, it makes sense to restrict some parameters, for example, pass
 *  REF: CALIB_SAME_FOCAL_LENGTH and REF: CALIB_ZERO_TANGENT_DIST flags, which is usually a
 * reasonable assumption.
 *
 * Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
 * points in all the available views from both cameras. The function returns the final value of the
 * re-projection error.
 */
+ (double)stereoCalibrateExtended:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F perViewErrors:(Mat*)perViewErrors flags:(int)flags NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:perViewErrors:flags:));

/**
 * Calibrates a stereo camera set up. This function finds the intrinsic parameters
 * for each of the two cameras and the extrinsic parameters between the two cameras.
 *
 * @param objectPoints Vector of vectors of the calibration pattern points. The same structure as
 * in REF: calibrateCamera. For each pattern view, both cameras need to see the same object
 * points. Therefore, objectPoints.size(), imagePoints1.size(), and imagePoints2.size() need to be
 * equal as well as objectPoints[i].size(), imagePoints1[i].size(), and imagePoints2[i].size() need to
 * be equal for each i.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 * observed by the first camera. The same structure as in REF: calibrateCamera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 * observed by the second camera. The same structure as in REF: calibrateCamera.
 * @param cameraMatrix1 Input/output camera intrinsic matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output second camera intrinsic matrix for the second camera. See description for
 * cameraMatrix1.
 * @param distCoeffs2 Input/output lens distortion coefficients for the second camera. See
 * description for distCoeffs1.
 * @param imageSize Size of the image used only to initialize the camera intrinsic matrices.
 * @param R Output rotation matrix. Together with the translation vector T, this matrix brings
 * points given in the first camera's coordinate system to points in the second camera's
 * coordinate system. In more technical terms, the tuple of R and T performs a change of basis
 * from the first camera's coordinate system to the second camera's coordinate system. Due to its
 * duality, this tuple is equivalent to the position of the first camera with respect to the
 * second camera coordinate system.
 * @param T Output translation vector, see description above.
 * @param E Output essential matrix.
 * @param F Output fundamental matrix.
 * @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
 * -   REF: CALIB_FIX_INTRINSIC Fix cameraMatrix? and distCoeffs? so that only R, T, E, and F
 * matrices are estimated.
 * -   REF: CALIB_USE_INTRINSIC_GUESS Optimize some or all of the intrinsic parameters
 * according to the specified flags. Initial values are provided by the user.
 * -   REF: CALIB_USE_EXTRINSIC_GUESS R and T contain valid initial values that are optimized further.
 * Otherwise R and T are initialized to the median value of the pattern views (each dimension separately).
 * -   REF: CALIB_FIX_PRINCIPAL_POINT Fix the principal points during the optimization.
 * -   REF: CALIB_FIX_FOCAL_LENGTH Fix `$$f^{(j)}_x$$` and `$$f^{(j)}_y$$` .
 * -   REF: CALIB_FIX_ASPECT_RATIO Optimize `$$f^{(j)}_y$$` . Fix the ratio `$$f^{(j)}_x/f^{(j)}_y$$`
 * .
 * -   REF: CALIB_SAME_FOCAL_LENGTH Enforce `$$f^{(0)}_x=f^{(1)}_x$$` and `$$f^{(0)}_y=f^{(1)}_y$$` .
 * -   REF: CALIB_ZERO_TANGENT_DIST Set tangential distortion coefficients for each camera to
 * zeros and fix there.
 * -   REF: CALIB_FIX_K1,..., REF: CALIB_FIX_K6 Do not change the corresponding radial
 * distortion coefficient during the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set,
 * the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_RATIONAL_MODEL Enable coefficients k4, k5, and k6. To provide the backward
 * compatibility, this extra flag should be explicitly specified to make the calibration
 * function use the rational model and return 8 coefficients. If the flag is not set, the
 * function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the thin prism model and return 12 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 * -   REF: CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
 * backward compatibility, this extra flag should be explicitly specified to make the
 * calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
 * set, the function computes and returns only 5 distortion coefficients.
 * -   REF: CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
 * the optimization. If REF: CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
 * supplied distCoeffs matrix is used. Otherwise, it is set to 0.
 *
 * The function estimates the transformation between two cameras making a stereo pair. If one computes
 * the poses of an object relative to the first camera and to the second camera,
 * ( `$$R_1$$`,`$$T_1$$` ) and (`$$R_2$$`,`$$T_2$$`), respectively, for a stereo camera where the
 * relative position and orientation between the two cameras are fixed, then those poses definitely
 * relate to each other. This means, if the relative position and orientation (`$$R$$`,`$$T$$`) of the
 * two cameras is known, it is possible to compute (`$$R_2$$`,`$$T_2$$`) when (`$$R_1$$`,`$$T_1$$`) is
 * given. This is what the described function does. It computes (`$$R$$`,`$$T$$`) such that:
 *
 * `$$R_2=R R_1$$`
 * `$$T_2=R T_1 + T.$$`
 *
 * Therefore, one can compute the coordinate representation of a 3D point for the second camera's
 * coordinate system when given the point's coordinate representation in the first camera's coordinate
 * system:
 *
 * `$$\begin{bmatrix}
 * X_2 \\
 * Y_2 \\
 * Z_2 \\
 * 1
 * \end{bmatrix} = \begin{bmatrix}
 * R & T \\
 * 0 & 1
 * \end{bmatrix} \begin{bmatrix}
 * X_1 \\
 * Y_1 \\
 * Z_1 \\
 * 1
 * \end{bmatrix}.$$`
 *
 *
 * Optionally, it computes the essential matrix E:
 *
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R$$`
 *
 * where `$$T_i$$` are components of the translation vector `$$T$$` : `$$T=[T_0, T_1, T_2]^T$$` .
 * And the function can also compute the fundamental matrix F:
 *
 * `$$F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}$$`
 *
 * Besides the stereo-related information, the function can also perform a full calibration of each of
 * the two cameras. However, due to the high dimensionality of the parameter space and noise in the
 * input data, the function can diverge from the correct solution. If the intrinsic parameters can be
 * estimated with high accuracy for each of the cameras individually (for example, using
 * #calibrateCamera ), you are recommended to do so and then pass REF: CALIB_FIX_INTRINSIC flag to the
 * function along with the computed intrinsic parameters. Otherwise, if all the parameters are
 * estimated at once, it makes sense to restrict some parameters, for example, pass
 *  REF: CALIB_SAME_FOCAL_LENGTH and REF: CALIB_ZERO_TANGENT_DIST flags, which is usually a
 * reasonable assumption.
 *
 * Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
 * points in all the available views from both cameras. The function returns the final value of the
 * re-projection error.
 */
+ (double)stereoCalibrateExtended:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F perViewErrors:(Mat*)perViewErrors NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:perViewErrors:));


//
//  double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
//
+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:flags:criteria:));

+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F flags:(int)flags NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:flags:));

+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T E:(Mat*)E F:(Mat*)F NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:E:F:));


//
//  void cv::stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags = CALIB_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect* validPixROI1 = 0, Rect* validPixROI2 = 0)
//
/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * @param flags Operation flags that may be zero or REF: CALIB_ZERO_DISPARITY . If the flag is set,
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * @param alpha Free scaling parameter. If it is -1 or absent, the function performs the default
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * @param validPixROI1 Optional output rectangles inside the rectified images where all the pixels
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * @param validPixROI2 Optional output rectangles inside the rectified images where all the pixels
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags alpha:(double)alpha newImageSize:(Size2i*)newImageSize validPixROI1:(Rect2i*)validPixROI1 validPixROI2:(Rect2i*)validPixROI2 NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:flags:alpha:newImageSize:validPixROI1:validPixROI2:));

/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * @param flags Operation flags that may be zero or REF: CALIB_ZERO_DISPARITY . If the flag is set,
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * @param alpha Free scaling parameter. If it is -1 or absent, the function performs the default
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * @param validPixROI1 Optional output rectangles inside the rectified images where all the pixels
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags alpha:(double)alpha newImageSize:(Size2i*)newImageSize validPixROI1:(Rect2i*)validPixROI1 NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:flags:alpha:newImageSize:validPixROI1:));

/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * @param flags Operation flags that may be zero or REF: CALIB_ZERO_DISPARITY . If the flag is set,
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * @param alpha Free scaling parameter. If it is -1 or absent, the function performs the default
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags alpha:(double)alpha newImageSize:(Size2i*)newImageSize NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:flags:alpha:newImageSize:));

/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * @param flags Operation flags that may be zero or REF: CALIB_ZERO_DISPARITY . If the flag is set,
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * @param alpha Free scaling parameter. If it is -1 or absent, the function performs the default
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags alpha:(double)alpha NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:flags:alpha:));

/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * @param flags Operation flags that may be zero or REF: CALIB_ZERO_DISPARITY . If the flag is set,
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:flags:));

/**
 * Computes rectification transforms for each head of a calibrated stereo camera.
 *
 * @param cameraMatrix1 First camera intrinsic matrix.
 * @param distCoeffs1 First camera distortion parameters.
 * @param cameraMatrix2 Second camera intrinsic matrix.
 * @param distCoeffs2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param T Translation vector from the coordinate system of the first camera to the second camera,
 * see REF: stereoCalibrate.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
 * brings points given in the unrectified first camera's coordinate system to points in the rectified
 * first camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified first camera's coordinate system to the rectified first camera's coordinate system.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
 * brings points given in the unrectified second camera's coordinate system to points in the rectified
 * second camera's coordinate system. In more technical terms, it performs a change of basis from the
 * unrectified second camera's coordinate system to the rectified second camera's coordinate system.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified first camera's image.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 * camera, i.e. it projects points given in the rectified first camera coordinate system into the
 * rectified second camera's image.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see REF: reprojectImageTo3D).
 * the function makes the principal points of each camera have the same pixel coordinates in the
 * rectified views. And if the flag is not set, the function may still shift the images in the
 * horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 * useful image area.
 * scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
 * images are zoomed and shifted so that only valid pixels are visible (no black areas after
 * rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
 * pixels from the original images from the cameras are retained in the rectified images (no source
 * image pixels are lost). Any intermediate value yields an intermediate result between
 * those two extreme cases.
 * #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 * is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
 * preserve details in the original image, especially when there is a big radial distortion.
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 * are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
 * (see the picture below).
 *
 * The function computes the rotation matrices for each camera that (virtually) make both camera image
 * planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
 * the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
 * as input. As output, it provides two rotation matrices and also two projection matrices in the new
 * coordinates. The function distinguishes the following two cases:
 *
 * -   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
 *     mainly along the x-axis (with possible small vertical shift). In the rectified images, the
 *     corresponding epipolar lines in the left and right cameras are horizontal and have the same
 *     y-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx_1 & 0 \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx_2 & T_x*f \\
 *                         0 & f & cy & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix} ,$$`
 *
 *     where `$$T_x$$` is a horizontal shift between the cameras and `$$cx_1=cx_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * -   **Vertical stereo**: the first and the second camera views are shifted relative to each other
 *     mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
 *     lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
 *
 *     `$$\texttt{P1} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_1 & 0 \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix}$$`
 *
 *     `$$\texttt{P2} = \begin{bmatrix}
 *                         f & 0 & cx & 0 \\
 *                         0 & f & cy_2 & T_y*f \\
 *                         0 & 0 & 1 & 0
 *                      \end{bmatrix},$$`
 *
 *     where `$$T_y$$` is a vertical shift between the cameras and `$$cy_1=cy_2$$` if
 *     REF: CALIB_ZERO_DISPARITY is set.
 *
 * As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
 * matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
 * initialize the rectification map for each camera.
 *
 * See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
 * the corresponding image regions. This means that the images are well rectified, which is what most
 * stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
 * their interiors are all valid pixels.
 *
 * ![image](pics/stereo_undistort.jpg)
 */
+ (void)stereoRectify:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q NS_SWIFT_NAME(stereoRectify(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:imageSize:R:T:R1:R2:P1:P2:Q:));


//
//  bool cv::stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat& H1, Mat& H2, double threshold = 5)
//
/**
 * Computes a rectification transform for an uncalibrated stereo camera.
 *
 * @param points1 Array of feature points in the first image.
 * @param points2 The corresponding points in the second image. The same formats as in
 * #findFundamentalMat are supported.
 * @param F Input fundamental matrix. It can be computed from the same set of point pairs using
 * #findFundamentalMat .
 * @param imgSize Size of the image.
 * @param H1 Output rectification homography matrix for the first image.
 * @param H2 Output rectification homography matrix for the second image.
 * @param threshold Optional threshold used to filter out the outliers. If the parameter is greater
 * than zero, all the point pairs that do not comply with the epipolar geometry (that is, the points
 * for which `$$|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}$$` ) are
 * rejected prior to computing the homographies. Otherwise, all the points are considered inliers.
 *
 * The function computes the rectification transformations without knowing intrinsic parameters of the
 * cameras and their relative position in the space, which explains the suffix "uncalibrated". Another
 * related difference from #stereoRectify is that the function outputs not the rectification
 * transformations in the object (3D) space, but the planar perspective transformations encoded by the
 * homography matrices H1 and H2 . The function implements the algorithm CITE: Hartley99 .
 *
 * NOTE:
 *    While the algorithm does not need to know the intrinsic parameters of the cameras, it heavily
 *     depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion,
 *     it would be better to correct it before computing the fundamental matrix and calling this
 *     function. For example, distortion coefficients can be estimated for each head of stereo camera
 *     separately by using #calibrateCamera . Then, the images can be corrected using #undistort , or
 *     just the point coordinates can be corrected with #undistortPoints .
 */
+ (BOOL)stereoRectifyUncalibrated:(Mat*)points1 points2:(Mat*)points2 F:(Mat*)F imgSize:(Size2i*)imgSize H1:(Mat*)H1 H2:(Mat*)H2 threshold:(double)threshold NS_SWIFT_NAME(stereoRectifyUncalibrated(points1:points2:F:imgSize:H1:H2:threshold:));

/**
 * Computes a rectification transform for an uncalibrated stereo camera.
 *
 * @param points1 Array of feature points in the first image.
 * @param points2 The corresponding points in the second image. The same formats as in
 * #findFundamentalMat are supported.
 * @param F Input fundamental matrix. It can be computed from the same set of point pairs using
 * #findFundamentalMat .
 * @param imgSize Size of the image.
 * @param H1 Output rectification homography matrix for the first image.
 * @param H2 Output rectification homography matrix for the second image.
 * than zero, all the point pairs that do not comply with the epipolar geometry (that is, the points
 * for which `$$|\texttt{points2[i]}^T*\texttt{F}*\texttt{points1[i]}|>\texttt{threshold}$$` ) are
 * rejected prior to computing the homographies. Otherwise, all the points are considered inliers.
 *
 * The function computes the rectification transformations without knowing intrinsic parameters of the
 * cameras and their relative position in the space, which explains the suffix "uncalibrated". Another
 * related difference from #stereoRectify is that the function outputs not the rectification
 * transformations in the object (3D) space, but the planar perspective transformations encoded by the
 * homography matrices H1 and H2 . The function implements the algorithm CITE: Hartley99 .
 *
 * NOTE:
 *    While the algorithm does not need to know the intrinsic parameters of the cameras, it heavily
 *     depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion,
 *     it would be better to correct it before computing the fundamental matrix and calling this
 *     function. For example, distortion coefficients can be estimated for each head of stereo camera
 *     separately by using #calibrateCamera . Then, the images can be corrected using #undistort , or
 *     just the point coordinates can be corrected with #undistortPoints .
 */
+ (BOOL)stereoRectifyUncalibrated:(Mat*)points1 points2:(Mat*)points2 F:(Mat*)F imgSize:(Size2i*)imgSize H1:(Mat*)H1 H2:(Mat*)H2 NS_SWIFT_NAME(stereoRectifyUncalibrated(points1:points2:F:imgSize:H1:H2:));


//
//  float cv::rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, vector_Mat imgpt1, vector_Mat imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q, double alpha, Size newImgSize, Rect* roi1, Rect* roi2, int flags)
//
+ (float)rectify3Collinear:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 cameraMatrix3:(Mat*)cameraMatrix3 distCoeffs3:(Mat*)distCoeffs3 imgpt1:(NSArray<Mat*>*)imgpt1 imgpt3:(NSArray<Mat*>*)imgpt3 imageSize:(Size2i*)imageSize R12:(Mat*)R12 T12:(Mat*)T12 R13:(Mat*)R13 T13:(Mat*)T13 R1:(Mat*)R1 R2:(Mat*)R2 R3:(Mat*)R3 P1:(Mat*)P1 P2:(Mat*)P2 P3:(Mat*)P3 Q:(Mat*)Q alpha:(double)alpha newImgSize:(Size2i*)newImgSize roi1:(Rect2i*)roi1 roi2:(Rect2i*)roi2 flags:(int)flags NS_SWIFT_NAME(rectify3Collinear(cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:cameraMatrix3:distCoeffs3:imgpt1:imgpt3:imageSize:R12:T12:R13:T13:R1:R2:R3:P1:P2:P3:Q:alpha:newImgSize:roi1:roi2:flags:));


//
//  Mat cv::getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), Rect* validPixROI = 0, bool centerPrincipalPoint = false)
//
/**
 * Returns the new camera intrinsic matrix based on the free scaling parameter.
 *
 * @param cameraMatrix Input camera intrinsic matrix.
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param imageSize Original image size.
 * @param alpha Free scaling parameter between 0 (when all the pixels in the undistorted image are
 * valid) and 1 (when all the source image pixels are retained in the undistorted image). See
 * #stereoRectify for details.
 * @param newImgSize Image size after rectification. By default, it is set to imageSize .
 * @param validPixROI Optional output rectangle that outlines all-good-pixels region in the
 * undistorted image. See roi1, roi2 description in #stereoRectify .
 * @param centerPrincipalPoint Optional flag that indicates whether in the new camera intrinsic matrix the
 * principal point should be at the image center or not. By default, the principal point is chosen to
 * best fit a subset of the source image (determined by alpha) to the corrected image.
 * @return new_camera_matrix Output new camera intrinsic matrix.
 *
 * The function computes and returns the optimal new camera intrinsic matrix based on the free scaling parameter.
 * By varying this parameter, you may retrieve only sensible pixels alpha=0 , keep all the original
 * image pixels if there is valuable information in the corners alpha=1 , or get something in between.
 * When alpha\>0 , the undistorted result is likely to have some black pixels corresponding to
 * "virtual" pixels outside of the captured distorted image. The original camera intrinsic matrix, distortion
 * coefficients, the computed new camera intrinsic matrix, and newImageSize should be passed to
 * #initUndistortRectifyMap to produce the maps for #remap .
 */
+ (Mat*)getOptimalNewCameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imageSize:(Size2i*)imageSize alpha:(double)alpha newImgSize:(Size2i*)newImgSize validPixROI:(Rect2i*)validPixROI centerPrincipalPoint:(BOOL)centerPrincipalPoint NS_SWIFT_NAME(getOptimalNewCameraMatrix(cameraMatrix:distCoeffs:imageSize:alpha:newImgSize:validPixROI:centerPrincipalPoint:));

/**
 * Returns the new camera intrinsic matrix based on the free scaling parameter.
 *
 * @param cameraMatrix Input camera intrinsic matrix.
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param imageSize Original image size.
 * @param alpha Free scaling parameter between 0 (when all the pixels in the undistorted image are
 * valid) and 1 (when all the source image pixels are retained in the undistorted image). See
 * #stereoRectify for details.
 * @param newImgSize Image size after rectification. By default, it is set to imageSize .
 * @param validPixROI Optional output rectangle that outlines all-good-pixels region in the
 * undistorted image. See roi1, roi2 description in #stereoRectify .
 * principal point should be at the image center or not. By default, the principal point is chosen to
 * best fit a subset of the source image (determined by alpha) to the corrected image.
 * @return new_camera_matrix Output new camera intrinsic matrix.
 *
 * The function computes and returns the optimal new camera intrinsic matrix based on the free scaling parameter.
 * By varying this parameter, you may retrieve only sensible pixels alpha=0 , keep all the original
 * image pixels if there is valuable information in the corners alpha=1 , or get something in between.
 * When alpha\>0 , the undistorted result is likely to have some black pixels corresponding to
 * "virtual" pixels outside of the captured distorted image. The original camera intrinsic matrix, distortion
 * coefficients, the computed new camera intrinsic matrix, and newImageSize should be passed to
 * #initUndistortRectifyMap to produce the maps for #remap .
 */
+ (Mat*)getOptimalNewCameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imageSize:(Size2i*)imageSize alpha:(double)alpha newImgSize:(Size2i*)newImgSize validPixROI:(Rect2i*)validPixROI NS_SWIFT_NAME(getOptimalNewCameraMatrix(cameraMatrix:distCoeffs:imageSize:alpha:newImgSize:validPixROI:));

/**
 * Returns the new camera intrinsic matrix based on the free scaling parameter.
 *
 * @param cameraMatrix Input camera intrinsic matrix.
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param imageSize Original image size.
 * @param alpha Free scaling parameter between 0 (when all the pixels in the undistorted image are
 * valid) and 1 (when all the source image pixels are retained in the undistorted image). See
 * #stereoRectify for details.
 * @param newImgSize Image size after rectification. By default, it is set to imageSize .
 * undistorted image. See roi1, roi2 description in #stereoRectify .
 * principal point should be at the image center or not. By default, the principal point is chosen to
 * best fit a subset of the source image (determined by alpha) to the corrected image.
 * @return new_camera_matrix Output new camera intrinsic matrix.
 *
 * The function computes and returns the optimal new camera intrinsic matrix based on the free scaling parameter.
 * By varying this parameter, you may retrieve only sensible pixels alpha=0 , keep all the original
 * image pixels if there is valuable information in the corners alpha=1 , or get something in between.
 * When alpha\>0 , the undistorted result is likely to have some black pixels corresponding to
 * "virtual" pixels outside of the captured distorted image. The original camera intrinsic matrix, distortion
 * coefficients, the computed new camera intrinsic matrix, and newImageSize should be passed to
 * #initUndistortRectifyMap to produce the maps for #remap .
 */
+ (Mat*)getOptimalNewCameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imageSize:(Size2i*)imageSize alpha:(double)alpha newImgSize:(Size2i*)newImgSize NS_SWIFT_NAME(getOptimalNewCameraMatrix(cameraMatrix:distCoeffs:imageSize:alpha:newImgSize:));

/**
 * Returns the new camera intrinsic matrix based on the free scaling parameter.
 *
 * @param cameraMatrix Input camera intrinsic matrix.
 * @param distCoeffs Input vector of distortion coefficients
 * `$$\distcoeffs$$`. If the vector is NULL/empty, the zero distortion coefficients are
 * assumed.
 * @param imageSize Original image size.
 * @param alpha Free scaling parameter between 0 (when all the pixels in the undistorted image are
 * valid) and 1 (when all the source image pixels are retained in the undistorted image). See
 * #stereoRectify for details.
 * undistorted image. See roi1, roi2 description in #stereoRectify .
 * principal point should be at the image center or not. By default, the principal point is chosen to
 * best fit a subset of the source image (determined by alpha) to the corrected image.
 * @return new_camera_matrix Output new camera intrinsic matrix.
 *
 * The function computes and returns the optimal new camera intrinsic matrix based on the free scaling parameter.
 * By varying this parameter, you may retrieve only sensible pixels alpha=0 , keep all the original
 * image pixels if there is valuable information in the corners alpha=1 , or get something in between.
 * When alpha\>0 , the undistorted result is likely to have some black pixels corresponding to
 * "virtual" pixels outside of the captured distorted image. The original camera intrinsic matrix, distortion
 * coefficients, the computed new camera intrinsic matrix, and newImageSize should be passed to
 * #initUndistortRectifyMap to produce the maps for #remap .
 */
+ (Mat*)getOptimalNewCameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs imageSize:(Size2i*)imageSize alpha:(double)alpha NS_SWIFT_NAME(getOptimalNewCameraMatrix(cameraMatrix:distCoeffs:imageSize:alpha:));


//
//  void cv::calibrateHandEye(vector_Mat R_gripper2base, vector_Mat t_gripper2base, vector_Mat R_target2cam, vector_Mat t_target2cam, Mat& R_cam2gripper, Mat& t_cam2gripper, HandEyeCalibrationMethod method = CALIB_HAND_EYE_TSAI)
//
/**
 * Computes Hand-Eye calibration: `$$_{}^{g}\textrm{T}_c$$`
 *
 * @param R_gripper2base Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the robot base frame (`$$_{}^{b}\textrm{T}_g$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from gripper frame to robot base frame.
 * @param t_gripper2base Translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the robot base frame (`$$_{}^{b}\textrm{T}_g$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from gripper frame to robot base frame.
 * @param R_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the target frame to the camera frame (`$$_{}^{c}\textrm{T}_t$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from calibration target frame to camera frame.
 * @param t_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the target frame to the camera frame (`$$_{}^{c}\textrm{T}_t$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from calibration target frame to camera frame.
 * @param R_cam2gripper Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the camera frame to the gripper frame (`$$_{}^{g}\textrm{T}_c$$`).
 * @param t_cam2gripper Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the camera frame to the gripper frame (`$$_{}^{g}\textrm{T}_c$$`).
 * @param method One of the implemented Hand-Eye calibration method, see cv::HandEyeCalibrationMethod
 *
 * The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the
 * rotation then the translation (separable solutions) and the following methods are implemented:
 *   - R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
 *   - F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
 *   - R. Horaud, F. Dornaika Hand-Eye Calibration \cite Horaud95
 *
 * Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
 * with the following implemented methods:
 *   - N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration \cite Andreff99
 *   - K. Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98
 *
 * The following picture describes the Hand-Eye calibration problem where the transformation between a camera ("eye")
 * mounted on a robot gripper ("hand") has to be estimated. This configuration is called eye-in-hand.
 *
 * The eye-to-hand configuration consists in a static camera observing a calibration pattern mounted on the robot
 * end-effector. The transformation from the camera to the robot base frame can then be estimated by inputting
 * the suitable transformations to the function, see below.
 *
 * ![](pics/hand-eye_figure.png)
 *
 * The calibration procedure is the following:
 *   - a static calibration pattern is used to estimate the transformation between the target frame
 *   and the camera frame
 *   - the robot gripper is moved in order to acquire several poses
 *   - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
 *   instance the robot kinematics
 * `$$
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 * $$`
 *   - for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using
 *   for instance a pose estimation method (PnP) from 2D-3D point correspondences
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_t\\
 *     Y_t\\
 *     Z_t\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * The Hand-Eye calibration procedure returns the following homogeneous transformation
 * `$$
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * This problem is also known as solving the `$$\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}$$` equation:
 *   - for an eye-in-hand configuration
 * `$$
 *     \begin{align*}
 *     ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
 *     \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
 *
 *     (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &=
 *     \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
 *
 *     \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
 *     \end{align*}
 * $$`
 *
 *   - for an eye-to-hand configuration
 * `$$
 *     \begin{align*}
 *     ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
 *     \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
 *
 *     (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &=
 *     \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
 *
 *     \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
 *     \end{align*}
 * $$`
 *
 * \note
 * Additional information can be found on this [website](http://campar.in.tum.de/Chair/HandEyeCalibration).
 * \note
 * A minimum of 2 motions with non parallel rotation axes are necessary to determine the hand-eye transformation.
 * So at least 3 different poses are required, but it is strongly recommended to use many more poses.
 */
+ (void)calibrateHandEye:(NSArray<Mat*>*)R_gripper2base t_gripper2base:(NSArray<Mat*>*)t_gripper2base R_target2cam:(NSArray<Mat*>*)R_target2cam t_target2cam:(NSArray<Mat*>*)t_target2cam R_cam2gripper:(Mat*)R_cam2gripper t_cam2gripper:(Mat*)t_cam2gripper method:(HandEyeCalibrationMethod)method NS_SWIFT_NAME(calibrateHandEye(R_gripper2base:t_gripper2base:R_target2cam:t_target2cam:R_cam2gripper:t_cam2gripper:method:));

/**
 * Computes Hand-Eye calibration: `$$_{}^{g}\textrm{T}_c$$`
 *
 * @param R_gripper2base Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the robot base frame (`$$_{}^{b}\textrm{T}_g$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from gripper frame to robot base frame.
 * @param t_gripper2base Translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the robot base frame (`$$_{}^{b}\textrm{T}_g$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from gripper frame to robot base frame.
 * @param R_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the target frame to the camera frame (`$$_{}^{c}\textrm{T}_t$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from calibration target frame to camera frame.
 * @param t_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the target frame to the camera frame (`$$_{}^{c}\textrm{T}_t$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from calibration target frame to camera frame.
 * @param R_cam2gripper Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the camera frame to the gripper frame (`$$_{}^{g}\textrm{T}_c$$`).
 * @param t_cam2gripper Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the camera frame to the gripper frame (`$$_{}^{g}\textrm{T}_c$$`).
 *
 * The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the
 * rotation then the translation (separable solutions) and the following methods are implemented:
 *   - R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
 *   - F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
 *   - R. Horaud, F. Dornaika Hand-Eye Calibration \cite Horaud95
 *
 * Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
 * with the following implemented methods:
 *   - N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration \cite Andreff99
 *   - K. Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98
 *
 * The following picture describes the Hand-Eye calibration problem where the transformation between a camera ("eye")
 * mounted on a robot gripper ("hand") has to be estimated. This configuration is called eye-in-hand.
 *
 * The eye-to-hand configuration consists in a static camera observing a calibration pattern mounted on the robot
 * end-effector. The transformation from the camera to the robot base frame can then be estimated by inputting
 * the suitable transformations to the function, see below.
 *
 * ![](pics/hand-eye_figure.png)
 *
 * The calibration procedure is the following:
 *   - a static calibration pattern is used to estimate the transformation between the target frame
 *   and the camera frame
 *   - the robot gripper is moved in order to acquire several poses
 *   - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
 *   instance the robot kinematics
 * `$$
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 * $$`
 *   - for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using
 *   for instance a pose estimation method (PnP) from 2D-3D point correspondences
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_t\\
 *     Y_t\\
 *     Z_t\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * The Hand-Eye calibration procedure returns the following homogeneous transformation
 * `$$
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * This problem is also known as solving the `$$\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}$$` equation:
 *   - for an eye-in-hand configuration
 * `$$
 *     \begin{align*}
 *     ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
 *     \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
 *
 *     (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &=
 *     \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
 *
 *     \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
 *     \end{align*}
 * $$`
 *
 *   - for an eye-to-hand configuration
 * `$$
 *     \begin{align*}
 *     ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
 *     \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
 *
 *     (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &=
 *     \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
 *
 *     \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
 *     \end{align*}
 * $$`
 *
 * \note
 * Additional information can be found on this [website](http://campar.in.tum.de/Chair/HandEyeCalibration).
 * \note
 * A minimum of 2 motions with non parallel rotation axes are necessary to determine the hand-eye transformation.
 * So at least 3 different poses are required, but it is strongly recommended to use many more poses.
 */
+ (void)calibrateHandEye:(NSArray<Mat*>*)R_gripper2base t_gripper2base:(NSArray<Mat*>*)t_gripper2base R_target2cam:(NSArray<Mat*>*)R_target2cam t_target2cam:(NSArray<Mat*>*)t_target2cam R_cam2gripper:(Mat*)R_cam2gripper t_cam2gripper:(Mat*)t_cam2gripper NS_SWIFT_NAME(calibrateHandEye(R_gripper2base:t_gripper2base:R_target2cam:t_target2cam:R_cam2gripper:t_cam2gripper:));


//
//  void cv::calibrateRobotWorldHandEye(vector_Mat R_world2cam, vector_Mat t_world2cam, vector_Mat R_base2gripper, vector_Mat t_base2gripper, Mat& R_base2world, Mat& t_base2world, Mat& R_gripper2cam, Mat& t_gripper2cam, RobotWorldHandEyeCalibrationMethod method = CALIB_ROBOT_WORLD_HAND_EYE_SHAH)
//
/**
 * Computes Robot-World/Hand-Eye calibration: `$$_{}^{w}\textrm{T}_b$$` and `$$_{}^{c}\textrm{T}_g$$`
 *
 * @param R_world2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the world frame to the camera frame (`$$_{}^{c}\textrm{T}_w$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from world frame to the camera frame.
 * @param t_world2cam Translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the world frame to the camera frame (`$$_{}^{c}\textrm{T}_w$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from world frame to the camera frame.
 * @param R_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the gripper frame (`$$_{}^{g}\textrm{T}_b$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from robot base frame to the gripper frame.
 * @param t_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the gripper frame (`$$_{}^{g}\textrm{T}_b$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from robot base frame to the gripper frame.
 * @param R_base2world Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the world frame (`$$_{}^{w}\textrm{T}_b$$`).
 * @param t_base2world Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the world frame (`$$_{}^{w}\textrm{T}_b$$`).
 * @param R_gripper2cam Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the camera frame (`$$_{}^{c}\textrm{T}_g$$`).
 * @param t_gripper2cam Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the camera frame (`$$_{}^{c}\textrm{T}_g$$`).
 * @param method One of the implemented Robot-World/Hand-Eye calibration method, see cv::RobotWorldHandEyeCalibrationMethod
 *
 * The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the
 * rotation then the translation (separable solutions):
 *   - M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR
 *
 * Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
 * with the following implemented method:
 *   - A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product \cite Li2010SimultaneousRA
 *
 * The following picture describes the Robot-World/Hand-Eye calibration problem where the transformations between a robot and a world frame
 * and between a robot gripper ("hand") and a camera ("eye") mounted at the robot end-effector have to be estimated.
 *
 * ![](pics/robot-world_hand-eye_figure.png)
 *
 * The calibration procedure is the following:
 *   - a static calibration pattern is used to estimate the transformation between the target frame
 *   and the camera frame
 *   - the robot gripper is moved in order to acquire several poses
 *   - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
 *   instance the robot kinematics
 * `$$
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 * $$`
 *   - for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using
 *   for instance a pose estimation method (PnP) from 2D-3D point correspondences
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_w\\
 *     Y_w\\
 *     Z_w\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * The Robot-World/Hand-Eye calibration procedure returns the following homogeneous transformations
 * `$$
 *     \begin{bmatrix}
 *     X_w\\
 *     Y_w\\
 *     Z_w\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 * $$`
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * This problem is also known as solving the `$$\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}$$` equation, with:
 *   - `$$\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w$$`
 *   - `$$\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b$$`
 *   - `$$\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g$$`
 *   - `$$\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b$$`
 *
 * \note
 * At least 3 measurements are required (input vectors size must be greater or equal to 3).
 */
+ (void)calibrateRobotWorldHandEye:(NSArray<Mat*>*)R_world2cam t_world2cam:(NSArray<Mat*>*)t_world2cam R_base2gripper:(NSArray<Mat*>*)R_base2gripper t_base2gripper:(NSArray<Mat*>*)t_base2gripper R_base2world:(Mat*)R_base2world t_base2world:(Mat*)t_base2world R_gripper2cam:(Mat*)R_gripper2cam t_gripper2cam:(Mat*)t_gripper2cam method:(RobotWorldHandEyeCalibrationMethod)method NS_SWIFT_NAME(calibrateRobotWorldHandEye(R_world2cam:t_world2cam:R_base2gripper:t_base2gripper:R_base2world:t_base2world:R_gripper2cam:t_gripper2cam:method:));

/**
 * Computes Robot-World/Hand-Eye calibration: `$$_{}^{w}\textrm{T}_b$$` and `$$_{}^{c}\textrm{T}_g$$`
 *
 * @param R_world2cam Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the world frame to the camera frame (`$$_{}^{c}\textrm{T}_w$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from world frame to the camera frame.
 * @param t_world2cam Translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the world frame to the camera frame (`$$_{}^{c}\textrm{T}_w$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from world frame to the camera frame.
 * @param R_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the gripper frame (`$$_{}^{g}\textrm{T}_b$$`).
 * This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
 * for all the transformations from robot base frame to the gripper frame.
 * @param t_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the gripper frame (`$$_{}^{g}\textrm{T}_b$$`).
 * This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
 * from robot base frame to the gripper frame.
 * @param R_base2world Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the world frame (`$$_{}^{w}\textrm{T}_b$$`).
 * @param t_base2world Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the robot base frame to the world frame (`$$_{}^{w}\textrm{T}_b$$`).
 * @param R_gripper2cam Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the camera frame (`$$_{}^{c}\textrm{T}_g$$`).
 * @param t_gripper2cam Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
 * expressed in the gripper frame to the camera frame (`$$_{}^{c}\textrm{T}_g$$`).
 *
 * The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the
 * rotation then the translation (separable solutions):
 *   - M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR
 *
 * Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
 * with the following implemented method:
 *   - A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product \cite Li2010SimultaneousRA
 *
 * The following picture describes the Robot-World/Hand-Eye calibration problem where the transformations between a robot and a world frame
 * and between a robot gripper ("hand") and a camera ("eye") mounted at the robot end-effector have to be estimated.
 *
 * ![](pics/robot-world_hand-eye_figure.png)
 *
 * The calibration procedure is the following:
 *   - a static calibration pattern is used to estimate the transformation between the target frame
 *   and the camera frame
 *   - the robot gripper is moved in order to acquire several poses
 *   - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
 *   instance the robot kinematics
 * `$$
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 * $$`
 *   - for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using
 *   for instance a pose estimation method (PnP) from 2D-3D point correspondences
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_w\\
 *     Y_w\\
 *     Z_w\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * The Robot-World/Hand-Eye calibration procedure returns the following homogeneous transformations
 * `$$
 *     \begin{bmatrix}
 *     X_w\\
 *     Y_w\\
 *     Z_w\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_b\\
 *     Y_b\\
 *     Z_b\\
 *     1
 *     \end{bmatrix}
 * $$`
 * `$$
 *     \begin{bmatrix}
 *     X_c\\
 *     Y_c\\
 *     Z_c\\
 *     1
 *     \end{bmatrix}
 *     =
 *     \begin{bmatrix}
 *     _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\
 *     0_{1 \times 3} & 1
 *     \end{bmatrix}
 *     \begin{bmatrix}
 *     X_g\\
 *     Y_g\\
 *     Z_g\\
 *     1
 *     \end{bmatrix}
 * $$`
 *
 * This problem is also known as solving the `$$\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}$$` equation, with:
 *   - `$$\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w$$`
 *   - `$$\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b$$`
 *   - `$$\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g$$`
 *   - `$$\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b$$`
 *
 * \note
 * At least 3 measurements are required (input vectors size must be greater or equal to 3).
 */
+ (void)calibrateRobotWorldHandEye:(NSArray<Mat*>*)R_world2cam t_world2cam:(NSArray<Mat*>*)t_world2cam R_base2gripper:(NSArray<Mat*>*)R_base2gripper t_base2gripper:(NSArray<Mat*>*)t_base2gripper R_base2world:(Mat*)R_base2world t_base2world:(Mat*)t_base2world R_gripper2cam:(Mat*)R_gripper2cam t_gripper2cam:(Mat*)t_gripper2cam NS_SWIFT_NAME(calibrateRobotWorldHandEye(R_world2cam:t_world2cam:R_base2gripper:t_base2gripper:R_base2world:t_base2world:R_gripper2cam:t_gripper2cam:));


//
//  void cv::convertPointsToHomogeneous(Mat src, Mat& dst)
//
/**
 * Converts points from Euclidean to homogeneous space.
 *
 * @param src Input vector of N-dimensional points.
 * @param dst Output vector of N+1-dimensional points.
 *
 * The function converts points from Euclidean to homogeneous space by appending 1's to the tuple of
 * point coordinates. That is, each point (x1, x2, ..., xn) is converted to (x1, x2, ..., xn, 1).
 */
+ (void)convertPointsToHomogeneous:(Mat*)src dst:(Mat*)dst NS_SWIFT_NAME(convertPointsToHomogeneous(src:dst:));


//
//  void cv::convertPointsFromHomogeneous(Mat src, Mat& dst)
//
/**
 * Converts points from homogeneous to Euclidean space.
 *
 * @param src Input vector of N-dimensional points.
 * @param dst Output vector of N-1-dimensional points.
 *
 * The function converts points homogeneous to Euclidean space using perspective projection. That is,
 * each point (x1, x2, ... x(n-1), xn) is converted to (x1/xn, x2/xn, ..., x(n-1)/xn). When xn=0, the
 * output point coordinates will be (0,0,0,...).
 */
+ (void)convertPointsFromHomogeneous:(Mat*)src dst:(Mat*)dst NS_SWIFT_NAME(convertPointsFromHomogeneous(src:dst:));


//
//  Mat cv::findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, int maxIters, Mat& mask = Mat())
//
/**
 * Calculates a fundamental matrix from the corresponding points in two images.
 *
 * @param points1 Array of N points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param method Method for computing a fundamental matrix.
 * -   REF: FM_7POINT for a 7-point algorithm. `$$N = 7$$`
 * -   REF: FM_8POINT for an 8-point algorithm. `$$N \ge 8$$`
 * -   REF: FM_RANSAC for the RANSAC algorithm. `$$N \ge 8$$`
 * -   REF: FM_LMEDS for the LMedS algorithm. `$$N \ge 8$$`
 * @param ransacReprojThreshold Parameter used only for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param confidence Parameter used for the RANSAC and LMedS methods only. It specifies a desirable level
 * of confidence (probability) that the estimated matrix is correct.
 * @param mask optional output mask
 * @param maxIters The maximum number of robust method iterations.
 *
 * The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T F [p_1; 1] = 0$$`
 *
 * where `$$F$$` is a fundamental matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively.
 *
 * The function calculates the fundamental matrix using one of four methods listed above and returns
 * the found fundamental matrix. Normally just one matrix is found. But in case of the 7-point
 * algorithm, the function may return up to 3 solutions ( `$$9 \times 3$$` matrix that stores all 3
 * matrices sequentially).
 *
 * The calculated fundamental matrix may be passed further to computeCorrespondEpilines that finds the
 * epipolar lines corresponding to the specified points. It can also be passed to
 * #stereoRectifyUncalibrated to compute the rectification transformation. :
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     Mat fundamental_matrix =
 *      findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
 *
 */
+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold confidence:(double)confidence maxIters:(int)maxIters mask:(Mat*)mask NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:ransacReprojThreshold:confidence:maxIters:mask:));

/**
 * Calculates a fundamental matrix from the corresponding points in two images.
 *
 * @param points1 Array of N points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param method Method for computing a fundamental matrix.
 * -   REF: FM_7POINT for a 7-point algorithm. `$$N = 7$$`
 * -   REF: FM_8POINT for an 8-point algorithm. `$$N \ge 8$$`
 * -   REF: FM_RANSAC for the RANSAC algorithm. `$$N \ge 8$$`
 * -   REF: FM_LMEDS for the LMedS algorithm. `$$N \ge 8$$`
 * @param ransacReprojThreshold Parameter used only for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param confidence Parameter used for the RANSAC and LMedS methods only. It specifies a desirable level
 * of confidence (probability) that the estimated matrix is correct.
 * @param maxIters The maximum number of robust method iterations.
 *
 * The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T F [p_1; 1] = 0$$`
 *
 * where `$$F$$` is a fundamental matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively.
 *
 * The function calculates the fundamental matrix using one of four methods listed above and returns
 * the found fundamental matrix. Normally just one matrix is found. But in case of the 7-point
 * algorithm, the function may return up to 3 solutions ( `$$9 \times 3$$` matrix that stores all 3
 * matrices sequentially).
 *
 * The calculated fundamental matrix may be passed further to computeCorrespondEpilines that finds the
 * epipolar lines corresponding to the specified points. It can also be passed to
 * #stereoRectifyUncalibrated to compute the rectification transformation. :
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     Mat fundamental_matrix =
 *      findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99);
 *
 */
+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold confidence:(double)confidence maxIters:(int)maxIters NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:ransacReprojThreshold:confidence:maxIters:));


//
//  Mat cv::findFundamentalMat(Mat points1, Mat points2, int method = FM_RANSAC, double ransacReprojThreshold = 3., double confidence = 0.99, Mat& mask = Mat())
//
+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold confidence:(double)confidence mask:(Mat*)mask NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:ransacReprojThreshold:confidence:mask:));

+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold confidence:(double)confidence NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:ransacReprojThreshold:confidence:));

+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:ransacReprojThreshold:));

+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 method:(int)method NS_SWIFT_NAME(findFundamentalMat(points1:points2:method:));

+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 NS_SWIFT_NAME(findFundamentalMat(points1:points2:));


//
//  Mat cv::findFundamentalMat(Mat points1, Mat points2, Mat& mask, UsacParams params)
//
+ (Mat*)findFundamentalMat:(Mat*)points1 points2:(Mat*)points2 mask:(Mat*)mask params:(UsacParams*)params NS_SWIFT_NAME(findFundamentalMat(points1:points2:mask:params:));


//
//  Mat cv::findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method = RANSAC, double prob = 0.999, double threshold = 1.0, int maxIters = 1000, Mat& mask = Mat())
//
/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param mask Output array of N elements, every element of which is set to 0 for outliers and to 1
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 * @param maxIters The maximum number of robust method iterations.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix method:(int)method prob:(double)prob threshold:(double)threshold maxIters:(int)maxIters mask:(Mat*)mask NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:method:prob:threshold:maxIters:mask:));

/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 * @param maxIters The maximum number of robust method iterations.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix method:(int)method prob:(double)prob threshold:(double)threshold maxIters:(int)maxIters NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:method:prob:threshold:maxIters:));

/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix method:(int)method prob:(double)prob threshold:(double)threshold NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:method:prob:threshold:));

/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix method:(int)method prob:(double)prob NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:method:prob:));

/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix method:(int)method NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:method:));

/**
 * Calculates an essential matrix from the corresponding points in two images.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera intrinsic matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix:));


//
//  Mat cv::findEssentialMat(Mat points1, Mat points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = RANSAC, double prob = 0.999, double threshold = 1.0, int maxIters = 1000, Mat& mask = Mat())
//
/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param method Method for computing a fundamental matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param mask Output array of N elements, every element of which is set to 0 for outliers and to 1
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 * @param maxIters The maximum number of robust method iterations.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp method:(int)method prob:(double)prob threshold:(double)threshold maxIters:(int)maxIters mask:(Mat*)mask NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:method:prob:threshold:maxIters:mask:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param method Method for computing a fundamental matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 * @param maxIters The maximum number of robust method iterations.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp method:(int)method prob:(double)prob threshold:(double)threshold maxIters:(int)maxIters NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:method:prob:threshold:maxIters:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param method Method for computing a fundamental matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp method:(int)method prob:(double)prob threshold:(double)threshold NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:method:prob:threshold:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param method Method for computing a fundamental matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp method:(int)method prob:(double)prob NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:method:prob:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param method Method for computing a fundamental matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp method:(int)method NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:method:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal pp:(Point2d*)pp NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:pp:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param focal focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 focal:(double)focal NS_SWIFT_NAME(findEssentialMat(points1:points2:focal:));

/**
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * are feature points from cameras with same focal length and principal point.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * confidence (probability) that the estimated matrix is correct.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 NS_SWIFT_NAME(findEssentialMat(points1:points2:));


//
//  Mat cv::findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
//
/**
 * Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param cameraMatrix2 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param distCoeffs1 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param distCoeffs2 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param mask Output array of N elements, every element of which is set to 0 for outliers and to 1
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 method:(int)method prob:(double)prob threshold:(double)threshold mask:(Mat*)mask NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:method:prob:threshold:mask:));

/**
 * Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param cameraMatrix2 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param distCoeffs1 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param distCoeffs2 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 method:(int)method prob:(double)prob threshold:(double)threshold NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:method:prob:threshold:));

/**
 * Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param cameraMatrix2 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param distCoeffs1 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param distCoeffs2 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 method:(int)method prob:(double)prob NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:method:prob:));

/**
 * Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param cameraMatrix2 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param distCoeffs1 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param distCoeffs2 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 method:(int)method NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:method:));

/**
 * Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 *
 * @param points1 Array of N (N \>= 5) 2D points from the first image. The point coordinates should
 * be floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param cameraMatrix2 Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } K = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera matrix. If this assumption does not hold for your use case, use
 * #undistortPoints with `P = cv::NoArray()` for both cameras to transform image points
 * to normalized image coordinates, which are valid for the identity camera matrix. When
 * passing these coordinates, pass the identity matrix for this parameter.
 * @param distCoeffs1 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param distCoeffs2 Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * for the other points. The array is computed only in the RANSAC and LMedS methods.
 *
 * This function estimates essential matrix based on the five-point algorithm solver in CITE: Nister03 .
 * CITE: SteweniusCFS is also a related. The epipolar geometry is described by the following equation:
 *
 * `$$[p_2; 1]^T K^{-T} E K^{-1} [p_1; 1] = 0$$`
 *
 * where `$$E$$` is an essential matrix, `$$p_1$$` and `$$p_2$$` are corresponding points in the first and the
 * second images, respectively. The result of this function may be passed further to
 * #decomposeEssentialMat or  #recoverPose to recover the relative pose between cameras.
 */
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:));


//
//  Mat cv::findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat cameraMatrix2, Mat dist_coeff1, Mat dist_coeff2, Mat& mask, UsacParams params)
//
+ (Mat*)findEssentialMat:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 cameraMatrix2:(Mat*)cameraMatrix2 dist_coeff1:(Mat*)dist_coeff1 dist_coeff2:(Mat*)dist_coeff2 mask:(Mat*)mask params:(UsacParams*)params NS_SWIFT_NAME(findEssentialMat(points1:points2:cameraMatrix1:cameraMatrix2:dist_coeff1:dist_coeff2:mask:params:));


//
//  void cv::decomposeEssentialMat(Mat E, Mat& R1, Mat& R2, Mat& t)
//
/**
 * Decompose an essential matrix to possible rotations and translation.
 *
 * @param E The input essential matrix.
 * @param R1 One possible rotation matrix.
 * @param R2 Another possible rotation matrix.
 * @param t One possible translation.
 *
 * This function decomposes the essential matrix E using svd decomposition CITE: HartleyZ00. In
 * general, four possible poses exist for the decomposition of E. They are `$$[R_1, t]$$`,
 * `$$[R_1, -t]$$`, `$$[R_2, t]$$`, `$$[R_2, -t]$$`.
 *
 * If E gives the epipolar constraint `$$[p_2; 1]^T A^{-T} E A^{-1} [p_1; 1] = 0$$` between the image
 * points `$$p_1$$` in the first image and `$$p_2$$` in second image, then any of the tuples
 * `$$[R_1, t]$$`, `$$[R_1, -t]$$`, `$$[R_2, t]$$`, `$$[R_2, -t]$$` is a change of basis from the first
 * camera's coordinate system to the second camera's coordinate system. However, by decomposing E, one
 * can only get the direction of the translation. For this reason, the translation t is returned with
 * unit length.
 */
+ (void)decomposeEssentialMat:(Mat*)E R1:(Mat*)R1 R2:(Mat*)R2 t:(Mat*)t NS_SWIFT_NAME(decomposeEssentialMat(E:R1:R2:t:));


//
//  int cv::recoverPose(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat& E, Mat& R, Mat& t, int method = cv::RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
//
/**
 * Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs2 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param E The output essential matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * @param mask Input/output mask for inliers in points1 and points2. If it is not empty, then it marks
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for findEssentialMat.:
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
 *     Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 *
 *     // Output: Essential matrix, relative rotation and relative translation.
 *     Mat E, R, t, mask;
 *
 *     recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 E:(Mat*)E R:(Mat*)R t:(Mat*)t method:(int)method prob:(double)prob threshold:(double)threshold mask:(Mat*)mask NS_SWIFT_NAME(recoverPose(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:E:R:t:method:prob:threshold:mask:));

/**
 * Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs2 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param E The output essential matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * @param threshold Parameter used for RANSAC. It is the maximum distance from a point to an epipolar
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for findEssentialMat.:
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
 *     Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 *
 *     // Output: Essential matrix, relative rotation and relative translation.
 *     Mat E, R, t, mask;
 *
 *     recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 E:(Mat*)E R:(Mat*)R t:(Mat*)t method:(int)method prob:(double)prob threshold:(double)threshold NS_SWIFT_NAME(recoverPose(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:E:R:t:method:prob:threshold:));

/**
 * Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs2 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param E The output essential matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * @param prob Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for findEssentialMat.:
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
 *     Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 *
 *     // Output: Essential matrix, relative rotation and relative translation.
 *     Mat E, R, t, mask;
 *
 *     recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 E:(Mat*)E R:(Mat*)R t:(Mat*)t method:(int)method prob:(double)prob NS_SWIFT_NAME(recoverPose(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:E:R:t:method:prob:));

/**
 * Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs2 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param E The output essential matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param method Method for computing an essential matrix.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for findEssentialMat.:
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
 *     Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 *
 *     // Output: Essential matrix, relative rotation and relative translation.
 *     Mat E, R, t, mask;
 *
 *     recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 E:(Mat*)E R:(Mat*)R t:(Mat*)t method:(int)method NS_SWIFT_NAME(recoverPose(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:E:R:t:method:));

/**
 * Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix1 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs1 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param cameraMatrix2 Input/output camera matrix for the first camera, the same as in
 * REF: calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
 * @param distCoeffs2 Input/output vector of distortion coefficients, the same as in
 * REF: calibrateCamera.
 * @param E The output essential matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * -   REF: RANSAC for the RANSAC algorithm.
 * -   REF: LMEDS for the LMedS algorithm.
 * confidence (probability) that the estimated matrix is correct.
 * line in pixels, beyond which the point is considered an outlier and is not used for computing the
 * final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the
 * point localization, image resolution, and the image noise.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for findEssentialMat.:
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // Input: camera calibration of both cameras, for example using intrinsic chessboard calibration.
 *     Mat cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2;
 *
 *     // Output: Essential matrix, relative rotation and relative translation.
 *     Mat E, R, t, mask;
 *
 *     recoverPose(points1, points2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, E, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)points1 points2:(Mat*)points2 cameraMatrix1:(Mat*)cameraMatrix1 distCoeffs1:(Mat*)distCoeffs1 cameraMatrix2:(Mat*)cameraMatrix2 distCoeffs2:(Mat*)distCoeffs2 E:(Mat*)E R:(Mat*)R t:(Mat*)t NS_SWIFT_NAME(recoverPose(points1:points2:cameraMatrix1:distCoeffs1:cameraMatrix2:distCoeffs2:E:R:t:));


//
//  int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, Mat& mask = Mat())
//
/**
 * Recovers the relative camera rotation and the translation from an estimated essential
 * matrix and the corresponding points in two images, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param mask Input/output mask for inliers in points1 and points2. If it is not empty, then it marks
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for #findEssentialMat :
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // cametra matrix with both focal lengths = 1, and principal point = (0, 0)
 *     Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
 *
 *     Mat E, R, t, mask;
 *
 *     E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask);
 *     recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix R:(Mat*)R t:(Mat*)t mask:(Mat*)mask NS_SWIFT_NAME(recoverPose(E:points1:points2:cameraMatrix:R:t:mask:));

/**
 * Recovers the relative camera rotation and the translation from an estimated essential
 * matrix and the corresponding points in two images, using cheirality check. Returns the number of
 * inliers that pass the check.
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * described below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function decomposes an essential matrix using REF: decomposeEssentialMat and then verifies
 * possible pose hypotheses by doing cheirality check. The cheirality check means that the
 * triangulated 3D points should have positive depth. Some details can be found in CITE: Nister03.
 *
 * This function can be used to process the output E and mask from REF: findEssentialMat. In this
 * scenario, points1 and points2 are the same input for #findEssentialMat :
 *
 *     // Example. Estimation of fundamental matrix using the RANSAC algorithm
 *     int point_count = 100;
 *     vector<Point2f> points1(point_count);
 *     vector<Point2f> points2(point_count);
 *
 *     // initialize the points here ...
 *     for( int i = 0; i < point_count; i++ )
 *     {
 *         points1[i] = ...;
 *         points2[i] = ...;
 *     }
 *
 *     // cametra matrix with both focal lengths = 1, and principal point = (0, 0)
 *     Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
 *
 *     Mat E, R, t, mask;
 *
 *     E = findEssentialMat(points1, points2, cameraMatrix, RANSAC, 0.999, 1.0, mask);
 *     recoverPose(E, points1, points2, cameraMatrix, R, t, mask);
 *
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix R:(Mat*)R t:(Mat*)t NS_SWIFT_NAME(recoverPose(E:points1:points2:cameraMatrix:R:t:));


//
//  int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat& R, Mat& t, double focal = 1.0, Point2d pp = Point2d(0, 0), Mat& mask = Mat())
//
/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param focal Focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * @param mask Input/output mask for inliers in points1 and points2. If it is not empty, then it marks
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 R:(Mat*)R t:(Mat*)t focal:(double)focal pp:(Point2d*)pp mask:(Mat*)mask NS_SWIFT_NAME(recoverPose(E:points1:points2:R:t:focal:pp:mask:));

/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param focal Focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * @param pp principal point of the camera.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 R:(Mat*)R t:(Mat*)t focal:(double)focal pp:(Point2d*)pp NS_SWIFT_NAME(recoverPose(E:points1:points2:R:t:focal:pp:));

/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param focal Focal length of the camera. Note that this function assumes that points1 and points2
 * are feature points from cameras with same focal length and principal point.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 R:(Mat*)R t:(Mat*)t focal:(double)focal NS_SWIFT_NAME(recoverPose(E:points1:points2:R:t:focal:));

/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1 .
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * are feature points from cameras with same focal length and principal point.
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it computes camera intrinsic matrix from focal length and
 * principal point:
 *
 * `$$A =
 * \begin{bmatrix}
 * f & 0 & x_{pp}  \\
 * 0 & f & y_{pp}  \\
 * 0 & 0 & 1
 * \end{bmatrix}$$`
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 R:(Mat*)R t:(Mat*)t NS_SWIFT_NAME(recoverPose(E:points1:points2:R:t:));


//
//  int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, double distanceThresh, Mat& mask = Mat(), Mat& triangulatedPoints = Mat())
//
/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param distanceThresh threshold distance which is used to filter out far away points (i.e. infinite
 * points).
 * @param mask Input/output mask for inliers in points1 and points2. If it is not empty, then it marks
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 * @param triangulatedPoints 3D points which were reconstructed by triangulation.
 *
 * This function differs from the one above that it outputs the triangulated 3D point that are used for
 * the cheirality check.
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix R:(Mat*)R t:(Mat*)t distanceThresh:(double)distanceThresh mask:(Mat*)mask triangulatedPoints:(Mat*)triangulatedPoints NS_SWIFT_NAME(recoverPose(E:points1:points2:cameraMatrix:R:t:distanceThresh:mask:triangulatedPoints:));

/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param distanceThresh threshold distance which is used to filter out far away points (i.e. infinite
 * points).
 * @param mask Input/output mask for inliers in points1 and points2. If it is not empty, then it marks
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it outputs the triangulated 3D point that are used for
 * the cheirality check.
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix R:(Mat*)R t:(Mat*)t distanceThresh:(double)distanceThresh mask:(Mat*)mask NS_SWIFT_NAME(recoverPose(E:points1:points2:cameraMatrix:R:t:distanceThresh:mask:));

/**
 *
 * @param E The input essential matrix.
 * @param points1 Array of N 2D points from the first image. The point coordinates should be
 * floating-point (single or double precision).
 * @param points2 Array of the second image points of the same size and format as points1.
 * @param cameraMatrix Camera intrinsic matrix `$$\cameramatrix{A}$$` .
 * Note that this function assumes that points1 and points2 are feature points from cameras with the
 * same camera intrinsic matrix.
 * @param R Output rotation matrix. Together with the translation vector, this matrix makes up a tuple
 * that performs a change of basis from the first camera's coordinate system to the second camera's
 * coordinate system. Note that, in general, t can not be used for this tuple, see the parameter
 * description below.
 * @param t Output translation vector. This vector is obtained by REF: decomposeEssentialMat and
 * therefore is only known up to scale, i.e. t is the direction of the translation vector and has unit
 * length.
 * @param distanceThresh threshold distance which is used to filter out far away points (i.e. infinite
 * points).
 * inliers in points1 and points2 for then given essential matrix E. Only these inliers will be used to
 * recover pose. In the output mask only inliers which pass the cheirality check.
 *
 * This function differs from the one above that it outputs the triangulated 3D point that are used for
 * the cheirality check.
 */
+ (int)recoverPose:(Mat*)E points1:(Mat*)points1 points2:(Mat*)points2 cameraMatrix:(Mat*)cameraMatrix R:(Mat*)R t:(Mat*)t distanceThresh:(double)distanceThresh NS_SWIFT_NAME(recoverPose(E:points1:points2:cameraMatrix:R:t:distanceThresh:));


//
//  void cv::computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat& lines)
//
/**
 * For points in an image of a stereo pair, computes the corresponding epilines in the other image.
 *
 * @param points Input points. `$$N \times 1$$` or `$$1 \times N$$` matrix of type CV_32FC2 or
 * vector\<Point2f\> .
 * @param whichImage Index of the image (1 or 2) that contains the points .
 * @param F Fundamental matrix that can be estimated using #findFundamentalMat or #stereoRectify .
 * @param lines Output vector of the epipolar lines corresponding to the points in the other image.
 * Each line `$$ax + by + c=0$$` is encoded by 3 numbers `$$(a, b, c)$$` .
 *
 * For every point in one of the two images of a stereo pair, the function finds the equation of the
 * corresponding epipolar line in the other image.
 *
 * From the fundamental matrix definition (see #findFundamentalMat ), line `$$l^{(2)}_i$$` in the second
 * image for the point `$$p^{(1)}_i$$` in the first image (when whichImage=1 ) is computed as:
 *
 * `$$l^{(2)}_i = F p^{(1)}_i$$`
 *
 * And vice versa, when whichImage=2, `$$l^{(1)}_i$$` is computed from `$$p^{(2)}_i$$` as:
 *
 * `$$l^{(1)}_i = F^T p^{(2)}_i$$`
 *
 * Line coefficients are defined up to a scale. They are normalized so that `$$a_i^2+b_i^2=1$$` .
 */
+ (void)computeCorrespondEpilines:(Mat*)points whichImage:(int)whichImage F:(Mat*)F lines:(Mat*)lines NS_SWIFT_NAME(computeCorrespondEpilines(points:whichImage:F:lines:));


//
//  void cv::triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat& points4D)
//
/**
 * This function reconstructs 3-dimensional points (in homogeneous coordinates) by using
 * their observations with a stereo camera.
 *
 * @param projMatr1 3x4 projection matrix of the first camera, i.e. this matrix projects 3D points
 * given in the world's coordinate system into the first image.
 * @param projMatr2 3x4 projection matrix of the second camera, i.e. this matrix projects 3D points
 * given in the world's coordinate system into the second image.
 * @param projPoints1 2xN array of feature points in the first image. In the case of the c++ version,
 * it can be also a vector of feature points or two-channel matrix of size 1xN or Nx1.
 * @param projPoints2 2xN array of corresponding points in the second image. In the case of the c++
 * version, it can be also a vector of feature points or two-channel matrix of size 1xN or Nx1.
 * @param points4D 4xN array of reconstructed points in homogeneous coordinates. These points are
 * returned in the world's coordinate system.
 *
 * NOTE:
 *    Keep in mind that all input data should be of float type in order for this function to work.
 *
 * NOTE:
 *    If the projection matrices from REF: stereoRectify are used, then the returned points are
 *    represented in the first camera's rectified coordinate system.
 *
 * @sa
 *    reprojectImageTo3D
 */
+ (void)triangulatePoints:(Mat*)projMatr1 projMatr2:(Mat*)projMatr2 projPoints1:(Mat*)projPoints1 projPoints2:(Mat*)projPoints2 points4D:(Mat*)points4D NS_SWIFT_NAME(triangulatePoints(projMatr1:projMatr2:projPoints1:projPoints2:points4D:));


//
//  void cv::correctMatches(Mat F, Mat points1, Mat points2, Mat& newPoints1, Mat& newPoints2)
//
/**
 * Refines coordinates of corresponding points.
 *
 * @param F 3x3 fundamental matrix.
 * @param points1 1xN array containing the first set of points.
 * @param points2 1xN array containing the second set of points.
 * @param newPoints1 The optimized points1.
 * @param newPoints2 The optimized points2.
 *
 * The function implements the Optimal Triangulation Method (see Multiple View Geometry for details).
 * For each given point correspondence points1[i] \<-\> points2[i], and a fundamental matrix F, it
 * computes the corrected correspondences newPoints1[i] \<-\> newPoints2[i] that minimize the geometric
 * error `$$d(points1[i], newPoints1[i])^2 + d(points2[i],newPoints2[i])^2$$` (where `$$d(a,b)$$` is the
 * geometric distance between points `$$a$$` and `$$b$$` ) subject to the epipolar constraint
 * `$$newPoints2^T * F * newPoints1 = 0$$` .
 */
+ (void)correctMatches:(Mat*)F points1:(Mat*)points1 points2:(Mat*)points2 newPoints1:(Mat*)newPoints1 newPoints2:(Mat*)newPoints2 NS_SWIFT_NAME(correctMatches(F:points1:points2:newPoints1:newPoints2:));


//
//  void cv::filterSpeckles(Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf = Mat())
//
/**
 * Filters off small noise blobs (speckles) in the disparity map
 *
 * @param img The input 16-bit signed disparity image
 * @param newVal The disparity value used to paint-off the speckles
 * @param maxSpeckleSize The maximum speckle size to consider it a speckle. Larger blobs are not
 * affected by the algorithm
 * @param maxDiff Maximum difference between neighbor disparity pixels to put them into the same
 * blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point
 * disparity map, where disparity values are multiplied by 16, this scale factor should be taken into
 * account when specifying this parameter value.
 * @param buf The optional temporary buffer to avoid memory allocation within the function.
 */
+ (void)filterSpeckles:(Mat*)img newVal:(double)newVal maxSpeckleSize:(int)maxSpeckleSize maxDiff:(double)maxDiff buf:(Mat*)buf NS_SWIFT_NAME(filterSpeckles(img:newVal:maxSpeckleSize:maxDiff:buf:));

/**
 * Filters off small noise blobs (speckles) in the disparity map
 *
 * @param img The input 16-bit signed disparity image
 * @param newVal The disparity value used to paint-off the speckles
 * @param maxSpeckleSize The maximum speckle size to consider it a speckle. Larger blobs are not
 * affected by the algorithm
 * @param maxDiff Maximum difference between neighbor disparity pixels to put them into the same
 * blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point
 * disparity map, where disparity values are multiplied by 16, this scale factor should be taken into
 * account when specifying this parameter value.
 */
+ (void)filterSpeckles:(Mat*)img newVal:(double)newVal maxSpeckleSize:(int)maxSpeckleSize maxDiff:(double)maxDiff NS_SWIFT_NAME(filterSpeckles(img:newVal:maxSpeckleSize:maxDiff:));


//
//  Rect cv::getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
//
+ (Rect2i*)getValidDisparityROI:(Rect2i*)roi1 roi2:(Rect2i*)roi2 minDisparity:(int)minDisparity numberOfDisparities:(int)numberOfDisparities blockSize:(int)blockSize NS_SWIFT_NAME(getValidDisparityROI(roi1:roi2:minDisparity:numberOfDisparities:blockSize:));


//
//  void cv::validateDisparity(Mat& disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1)
//
+ (void)validateDisparity:(Mat*)disparity cost:(Mat*)cost minDisparity:(int)minDisparity numberOfDisparities:(int)numberOfDisparities disp12MaxDisp:(int)disp12MaxDisp NS_SWIFT_NAME(validateDisparity(disparity:cost:minDisparity:numberOfDisparities:disp12MaxDisp:));

+ (void)validateDisparity:(Mat*)disparity cost:(Mat*)cost minDisparity:(int)minDisparity numberOfDisparities:(int)numberOfDisparities NS_SWIFT_NAME(validateDisparity(disparity:cost:minDisparity:numberOfDisparities:));


//
//  void cv::reprojectImageTo3D(Mat disparity, Mat& _3dImage, Mat Q, bool handleMissingValues = false, int ddepth = -1)
//
/**
 * Reprojects a disparity image to 3D space.
 *
 * @param disparity Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit
 * floating-point disparity image. The values of 8-bit / 16-bit signed formats are assumed to have no
 * fractional bits. If the disparity is 16-bit signed format, as computed by REF: StereoBM or
 * REF: StereoSGBM and maybe other algorithms, it should be divided by 16 (and scaled to float) before
 * being used here.
 * @param _3dImage Output 3-channel floating-point image of the same size as disparity. Each element of
 * _3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity map. If one
 * uses Q obtained by REF: stereoRectify, then the returned points are represented in the first
 * camera's rectified coordinate system.
 * @param Q `$$4 \times 4$$` perspective transformation matrix that can be obtained with
 * REF: stereoRectify.
 * @param handleMissingValues Indicates, whether the function should handle missing values (i.e.
 * points where the disparity was not computed). If handleMissingValues=true, then pixels with the
 * minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed
 * to 3D points with a very large Z value (currently set to 10000).
 * @param ddepth The optional output array depth. If it is -1, the output image will have CV_32F
 * depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.
 *
 * The function transforms a single-channel disparity map to a 3-channel image representing a 3D
 * surface. That is, for each pixel (x,y) and the corresponding disparity d=disparity(x,y) , it
 * computes:
 *
 * `$$\begin{bmatrix}
 * X \\
 * Y \\
 * Z \\
 * W
 * \end{bmatrix} = Q \begin{bmatrix}
 * x \\
 * y \\
 * \texttt{disparity} (x,y) \\
 * z
 * \end{bmatrix}.$$`
 *
 * @sa
 *    To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform.
 */
+ (void)reprojectImageTo3D:(Mat*)disparity _3dImage:(Mat*)_3dImage Q:(Mat*)Q handleMissingValues:(BOOL)handleMissingValues ddepth:(int)ddepth NS_SWIFT_NAME(reprojectImageTo3D(disparity:_3dImage:Q:handleMissingValues:ddepth:));

/**
 * Reprojects a disparity image to 3D space.
 *
 * @param disparity Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit
 * floating-point disparity image. The values of 8-bit / 16-bit signed formats are assumed to have no
 * fractional bits. If the disparity is 16-bit signed format, as computed by REF: StereoBM or
 * REF: StereoSGBM and maybe other algorithms, it should be divided by 16 (and scaled to float) before
 * being used here.
 * @param _3dImage Output 3-channel floating-point image of the same size as disparity. Each element of
 * _3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity map. If one
 * uses Q obtained by REF: stereoRectify, then the returned points are represented in the first
 * camera's rectified coordinate system.
 * @param Q `$$4 \times 4$$` perspective transformation matrix that can be obtained with
 * REF: stereoRectify.
 * @param handleMissingValues Indicates, whether the function should handle missing values (i.e.
 * points where the disparity was not computed). If handleMissingValues=true, then pixels with the
 * minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed
 * to 3D points with a very large Z value (currently set to 10000).
 * depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.
 *
 * The function transforms a single-channel disparity map to a 3-channel image representing a 3D
 * surface. That is, for each pixel (x,y) and the corresponding disparity d=disparity(x,y) , it
 * computes:
 *
 * `$$\begin{bmatrix}
 * X \\
 * Y \\
 * Z \\
 * W
 * \end{bmatrix} = Q \begin{bmatrix}
 * x \\
 * y \\
 * \texttt{disparity} (x,y) \\
 * z
 * \end{bmatrix}.$$`
 *
 * @sa
 *    To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform.
 */
+ (void)reprojectImageTo3D:(Mat*)disparity _3dImage:(Mat*)_3dImage Q:(Mat*)Q handleMissingValues:(BOOL)handleMissingValues NS_SWIFT_NAME(reprojectImageTo3D(disparity:_3dImage:Q:handleMissingValues:));

/**
 * Reprojects a disparity image to 3D space.
 *
 * @param disparity Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit
 * floating-point disparity image. The values of 8-bit / 16-bit signed formats are assumed to have no
 * fractional bits. If the disparity is 16-bit signed format, as computed by REF: StereoBM or
 * REF: StereoSGBM and maybe other algorithms, it should be divided by 16 (and scaled to float) before
 * being used here.
 * @param _3dImage Output 3-channel floating-point image of the same size as disparity. Each element of
 * _3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity map. If one
 * uses Q obtained by REF: stereoRectify, then the returned points are represented in the first
 * camera's rectified coordinate system.
 * @param Q `$$4 \times 4$$` perspective transformation matrix that can be obtained with
 * REF: stereoRectify.
 * points where the disparity was not computed). If handleMissingValues=true, then pixels with the
 * minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed
 * to 3D points with a very large Z value (currently set to 10000).
 * depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.
 *
 * The function transforms a single-channel disparity map to a 3-channel image representing a 3D
 * surface. That is, for each pixel (x,y) and the corresponding disparity d=disparity(x,y) , it
 * computes:
 *
 * `$$\begin{bmatrix}
 * X \\
 * Y \\
 * Z \\
 * W
 * \end{bmatrix} = Q \begin{bmatrix}
 * x \\
 * y \\
 * \texttt{disparity} (x,y) \\
 * z
 * \end{bmatrix}.$$`
 *
 * @sa
 *    To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform.
 */
+ (void)reprojectImageTo3D:(Mat*)disparity _3dImage:(Mat*)_3dImage Q:(Mat*)Q NS_SWIFT_NAME(reprojectImageTo3D(disparity:_3dImage:Q:));


//
//  double cv::sampsonDistance(Mat pt1, Mat pt2, Mat F)
//
/**
 * Calculates the Sampson Distance between two points.
 *
 * The function cv::sampsonDistance calculates and returns the first order approximation of the geometric error as:
 * `$$
 * sd( \texttt{pt1} , \texttt{pt2} )=
 * \frac{(\texttt{pt2}^t \cdot \texttt{F} \cdot \texttt{pt1})^2}
 * {((\texttt{F} \cdot \texttt{pt1})(0))^2 +
 * ((\texttt{F} \cdot \texttt{pt1})(1))^2 +
 * ((\texttt{F}^t \cdot \texttt{pt2})(0))^2 +
 * ((\texttt{F}^t \cdot \texttt{pt2})(1))^2}
 * $$`
 * The fundamental matrix may be calculated using the #findFundamentalMat function. See CITE: HartleyZ00 11.4.3 for details.
 * @param pt1 first homogeneous 2d point
 * @param pt2 second homogeneous 2d point
 * @param F fundamental matrix
 * @return The computed Sampson distance.
 */
+ (double)sampsonDistance:(Mat*)pt1 pt2:(Mat*)pt2 F:(Mat*)F NS_SWIFT_NAME(sampsonDistance(pt1:pt2:F:));


//
//  int cv::estimateAffine3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99)
//
/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13}\\
 * a_{21} & a_{22} & a_{23}\\
 * a_{31} & a_{32} & a_{33}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13} & b_1\\
 * a_{21} & a_{22} & a_{23} & b_2\\
 * a_{31} & a_{32} & a_{33} & b_3\\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param ransacThreshold Maximum reprojection error in the RANSAC algorithm to consider a point as
 * an inlier.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D affine transformation between two 3D point sets using the
 * RANSAC algorithm.
 */
+ (int)estimateAffine3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers ransacThreshold:(double)ransacThreshold confidence:(double)confidence NS_SWIFT_NAME(estimateAffine3D(src:dst:out:inliers:ransacThreshold:confidence:));

/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13}\\
 * a_{21} & a_{22} & a_{23}\\
 * a_{31} & a_{32} & a_{33}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13} & b_1\\
 * a_{21} & a_{22} & a_{23} & b_2\\
 * a_{31} & a_{32} & a_{33} & b_3\\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param ransacThreshold Maximum reprojection error in the RANSAC algorithm to consider a point as
 * an inlier.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D affine transformation between two 3D point sets using the
 * RANSAC algorithm.
 */
+ (int)estimateAffine3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers ransacThreshold:(double)ransacThreshold NS_SWIFT_NAME(estimateAffine3D(src:dst:out:inliers:ransacThreshold:));

/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13}\\
 * a_{21} & a_{22} & a_{23}\\
 * a_{31} & a_{32} & a_{33}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & a_{13} & b_1\\
 * a_{21} & a_{22} & a_{23} & b_2\\
 * a_{31} & a_{32} & a_{33} & b_3\\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * an inlier.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D affine transformation between two 3D point sets using the
 * RANSAC algorithm.
 */
+ (int)estimateAffine3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers NS_SWIFT_NAME(estimateAffine3D(src:dst:out:inliers:));


//
//  Mat cv::estimateAffine3D(Mat src, Mat dst, double* scale = nullptr, bool force_rotation = true)
//
/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes `$$R,s,t$$` minimizing `$$\sum{i} dst_i - c \cdot R \cdot src_i $$`
 * where `$$R$$` is a 3x3 rotation matrix, `$$t$$` is a 3x1 translation vector and `$$s$$` is a
 * scalar size value. This is an implementation of the algorithm by Umeyama \cite umeyama1991least .
 * The estimated affine transform has a homogeneous scale which is a subclass of affine
 * transformations with 7 degrees of freedom. The paired point sets need to comprise at least 3
 * points each.
 *
 * @param src First input 3D point set.
 * @param dst Second input 3D point set.
 * @param scale If null is passed, the scale parameter c will be assumed to be 1.0.
 * Else the pointed-to variable will be set to the optimal scale.
 * @param force_rotation If true, the returned rotation will never be a reflection.
 * This might be unwanted, e.g. when optimizing a transform between a right- and a
 * left-handed coordinate system.
 * @return 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$T =
 * \begin{bmatrix}
 * R & t\\
 * \end{bmatrix}
 * $$`
 */
+ (Mat*)estimateAffine3D:(Mat*)src dst:(Mat*)dst scale:(double*)scale force_rotation:(BOOL)force_rotation NS_SWIFT_NAME(estimateAffine3D(src:dst:scale:force_rotation:));

/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes `$$R,s,t$$` minimizing `$$\sum{i} dst_i - c \cdot R \cdot src_i $$`
 * where `$$R$$` is a 3x3 rotation matrix, `$$t$$` is a 3x1 translation vector and `$$s$$` is a
 * scalar size value. This is an implementation of the algorithm by Umeyama \cite umeyama1991least .
 * The estimated affine transform has a homogeneous scale which is a subclass of affine
 * transformations with 7 degrees of freedom. The paired point sets need to comprise at least 3
 * points each.
 *
 * @param src First input 3D point set.
 * @param dst Second input 3D point set.
 * @param scale If null is passed, the scale parameter c will be assumed to be 1.0.
 * Else the pointed-to variable will be set to the optimal scale.
 * This might be unwanted, e.g. when optimizing a transform between a right- and a
 * left-handed coordinate system.
 * @return 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$T =
 * \begin{bmatrix}
 * R & t\\
 * \end{bmatrix}
 * $$`
 */
+ (Mat*)estimateAffine3D:(Mat*)src dst:(Mat*)dst scale:(double*)scale NS_SWIFT_NAME(estimateAffine3D(src:dst:scale:));

/**
 * Computes an optimal affine transformation between two 3D point sets.
 *
 * It computes `$$R,s,t$$` minimizing `$$\sum{i} dst_i - c \cdot R \cdot src_i $$`
 * where `$$R$$` is a 3x3 rotation matrix, `$$t$$` is a 3x1 translation vector and `$$s$$` is a
 * scalar size value. This is an implementation of the algorithm by Umeyama \cite umeyama1991least .
 * The estimated affine transform has a homogeneous scale which is a subclass of affine
 * transformations with 7 degrees of freedom. The paired point sets need to comprise at least 3
 * points each.
 *
 * @param src First input 3D point set.
 * @param dst Second input 3D point set.
 * Else the pointed-to variable will be set to the optimal scale.
 * This might be unwanted, e.g. when optimizing a transform between a right- and a
 * left-handed coordinate system.
 * @return 3D affine transformation matrix `$$3 \times 4$$` of the form
 * `$$T =
 * \begin{bmatrix}
 * R & t\\
 * \end{bmatrix}
 * $$`
 */
+ (Mat*)estimateAffine3D:(Mat*)src dst:(Mat*)dst NS_SWIFT_NAME(estimateAffine3D(src:dst:));


//
//  int cv::estimateTranslation3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99)
//
/**
 * Computes an optimal translation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D translation vector `$$3 \times 1$$` of the form
 * `$$
 * \begin{bmatrix}
 * b_1 \\
 * b_2 \\
 * b_3 \\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param ransacThreshold Maximum reprojection error in the RANSAC algorithm to consider a point as
 * an inlier.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D translation between two 3D point sets using the
 * RANSAC algorithm.
 *
 */
+ (int)estimateTranslation3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers ransacThreshold:(double)ransacThreshold confidence:(double)confidence NS_SWIFT_NAME(estimateTranslation3D(src:dst:out:inliers:ransacThreshold:confidence:));

/**
 * Computes an optimal translation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D translation vector `$$3 \times 1$$` of the form
 * `$$
 * \begin{bmatrix}
 * b_1 \\
 * b_2 \\
 * b_3 \\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param ransacThreshold Maximum reprojection error in the RANSAC algorithm to consider a point as
 * an inlier.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D translation between two 3D point sets using the
 * RANSAC algorithm.
 *
 */
+ (int)estimateTranslation3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers ransacThreshold:(double)ransacThreshold NS_SWIFT_NAME(estimateTranslation3D(src:dst:out:inliers:ransacThreshold:));

/**
 * Computes an optimal translation between two 3D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * z\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * X\\
 * Y\\
 * Z\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * b_3\\
 * \end{bmatrix}
 * $$`
 *
 * @param src First input 3D point set containing `$$(X,Y,Z)$$`.
 * @param dst Second input 3D point set containing `$$(x,y,z)$$`.
 * @param out Output 3D translation vector `$$3 \times 1$$` of the form
 * `$$
 * \begin{bmatrix}
 * b_1 \\
 * b_2 \\
 * b_3 \\
 * \end{bmatrix}
 * $$`
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * an inlier.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 *
 * The function estimates an optimal 3D translation between two 3D point sets using the
 * RANSAC algorithm.
 *
 */
+ (int)estimateTranslation3D:(Mat*)src dst:(Mat*)dst out:(Mat*)out inliers:(Mat*)inliers NS_SWIFT_NAME(estimateTranslation3D(src:dst:out:inliers:));


//
//  Mat cv::estimateAffine2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
//
/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * @param refineIters Maximum number of iterations of refining algorithm (Levenberg-Marquardt).
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters confidence:(double)confidence refineIters:(size_t)refineIters NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters confidence:(double)confidence NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:method:ransacReprojThreshold:maxIters:confidence:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:method:ransacReprojThreshold:maxIters:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:method:ransacReprojThreshold:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:method:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * @param inliers Output vector indicating which points are inliers (1-inlier, 0-outlier).
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers NS_SWIFT_NAME(estimateAffine2D(from:to:inliers:));

/**
 * Computes an optimal affine transformation between two 2D point sets.
 *
 * It computes
 * `$$
 * \begin{bmatrix}
 * x\\
 * y\\
 * \end{bmatrix}
 * =
 * \begin{bmatrix}
 * a_{11} & a_{12}\\
 * a_{21} & a_{22}\\
 * \end{bmatrix}
 * \begin{bmatrix}
 * X\\
 * Y\\
 * \end{bmatrix}
 * +
 * \begin{bmatrix}
 * b_1\\
 * b_2\\
 * \end{bmatrix}
 * $$`
 *
 * @param from First input 2D point set containing `$$(X,Y)$$`.
 * @param to Second input 2D point set containing `$$(x,y)$$`.
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation matrix `$$2 \times 3$$` or empty matrix if transformation
 * could not be estimated. The returned matrix has the following form:
 * `$$
 * \begin{bmatrix}
 * a_{11} & a_{12} & b_1\\
 * a_{21} & a_{22} & b_2\\
 * \end{bmatrix}
 * $$`
 *
 * The function estimates an optimal 2D affine transformation between two 2D point sets using the
 * selected robust algorithm.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but needs a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffinePartial2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffine2D:(Mat*)from to:(Mat*)to NS_SWIFT_NAME(estimateAffine2D(from:to:));


//
//  Mat cv::estimateAffine2D(Mat pts1, Mat pts2, Mat& inliers, UsacParams params)
//
+ (Mat*)estimateAffine2D:(Mat*)pts1 pts2:(Mat*)pts2 inliers:(Mat*)inliers params:(UsacParams*)params NS_SWIFT_NAME(estimateAffine2D(pts1:pts2:inliers:params:));


//
//  Mat cv::estimateAffinePartial2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
//
/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * @param refineIters Maximum number of iterations of refining algorithm (Levenberg-Marquardt).
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters confidence:(double)confidence refineIters:(size_t)refineIters NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * @param confidence Confidence level, between 0 and 1, for the estimated transformation. Anything
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters confidence:(double)confidence NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:method:ransacReprojThreshold:maxIters:confidence:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * @param maxIters The maximum number of robust method iterations.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold maxIters:(size_t)maxIters NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:method:ransacReprojThreshold:maxIters:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * @param ransacReprojThreshold Maximum reprojection error in the RANSAC algorithm to consider
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method ransacReprojThreshold:(double)ransacReprojThreshold NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:method:ransacReprojThreshold:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * @param method Robust method used to compute transformation. The following methods are possible:
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers method:(int)method NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:method:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * @param inliers Output vector indicating which points are inliers.
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to inliers:(Mat*)inliers NS_SWIFT_NAME(estimateAffinePartial2D(from:to:inliers:));

/**
 * Computes an optimal limited affine transformation with 4 degrees of freedom between
 * two 2D point sets.
 *
 * @param from First input 2D point set.
 * @param to Second input 2D point set.
 * -   REF: RANSAC - RANSAC-based robust method
 * -   REF: LMEDS - Least-Median robust method
 * RANSAC is the default method.
 * a point as an inlier. Applies only to RANSAC.
 * between 0.95 and 0.99 is usually good enough. Values too close to 1 can slow down the estimation
 * significantly. Values lower than 0.8-0.9 can result in an incorrectly estimated transformation.
 * Passing 0 will disable refining, so the output matrix will be output of robust method.
 *
 * @return Output 2D affine transformation (4 degrees of freedom) matrix `$$2 \times 3$$` or
 * empty matrix if transformation could not be estimated.
 *
 * The function estimates an optimal 2D affine transformation with 4 degrees of freedom limited to
 * combinations of translation, rotation, and uniform scaling. Uses the selected algorithm for robust
 * estimation.
 *
 * The computed transformation is then refined further (using only inliers) with the
 * Levenberg-Marquardt method to reduce the re-projection error even more.
 *
 * Estimated transformation matrix is:
 * `$$ \begin{bmatrix} \cos(\theta) \cdot s & -\sin(\theta) \cdot s & t_x \\
 *                 \sin(\theta) \cdot s & \cos(\theta) \cdot s & t_y
 * \end{bmatrix} $$`
 * Where `$$ \theta $$` is the rotation angle, `$$ s $$` the scaling factor and `$$ t_x, t_y $$` are
 * translations in `$$ x, y $$` axes respectively.
 *
 * NOTE:
 * The RANSAC method can handle practically any ratio of outliers but need a threshold to
 * distinguish inliers from outliers. The method LMeDS does not need any threshold but it works
 * correctly only when there are more than 50% of inliers.
 *
 * @see `+estimateAffine2D:to:inliers:method:ransacReprojThreshold:maxIters:confidence:refineIters:`, `getAffineTransform`
 */
+ (Mat*)estimateAffinePartial2D:(Mat*)from to:(Mat*)to NS_SWIFT_NAME(estimateAffinePartial2D(from:to:));


//
//  int cv::decomposeHomographyMat(Mat H, Mat K, vector_Mat& rotations, vector_Mat& translations, vector_Mat& normals)
//
/**
 * Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
 *
 * @param H The input homography matrix between two images.
 * @param K The input camera intrinsic matrix.
 * @param rotations Array of rotation matrices.
 * @param translations Array of translation matrices.
 * @param normals Array of plane normal matrices.
 *
 * This function extracts relative camera motion between two views of a planar object and returns up to
 * four mathematical solution tuples of rotation, translation, and plane normal. The decomposition of
 * the homography matrix H is described in detail in CITE: Malis.
 *
 * If the homography H, induced by the plane, gives the constraint
 * `$$s_i \vecthree{x'_i}{y'_i}{1} \sim H \vecthree{x_i}{y_i}{1}$$` on the source image points
 * `$$p_i$$` and the destination image points `$$p'_i$$`, then the tuple of rotations[k] and
 * translations[k] is a change of basis from the source camera's coordinate system to the destination
 * camera's coordinate system. However, by decomposing H, one can only get the translation normalized
 * by the (typically unknown) depth of the scene, i.e. its direction but with normalized length.
 *
 * If point correspondences are available, at least two solutions may further be invalidated, by
 * applying positive depth constraint, i.e. all points must be in front of the camera.
 */
+ (int)decomposeHomographyMat:(Mat*)H K:(Mat*)K rotations:(NSMutableArray<Mat*>*)rotations translations:(NSMutableArray<Mat*>*)translations normals:(NSMutableArray<Mat*>*)normals NS_SWIFT_NAME(decomposeHomographyMat(H:K:rotations:translations:normals:));


//
//  void cv::filterHomographyDecompByVisibleRefpoints(vector_Mat rotations, vector_Mat normals, Mat beforePoints, Mat afterPoints, Mat& possibleSolutions, Mat pointsMask = Mat())
//
/**
 * Filters homography decompositions based on additional information.
 *
 * @param rotations Vector of rotation matrices.
 * @param normals Vector of plane normal matrices.
 * @param beforePoints Vector of (rectified) visible reference points before the homography is applied
 * @param afterPoints Vector of (rectified) visible reference points after the homography is applied
 * @param possibleSolutions Vector of int indices representing the viable solution set after filtering
 * @param pointsMask optional Mat/Vector of 8u type representing the mask for the inliers as given by the #findHomography function
 *
 * This function is intended to filter the output of the #decomposeHomographyMat based on additional
 * information as described in CITE: Malis . The summary of the method: the #decomposeHomographyMat function
 * returns 2 unique solutions and their "opposites" for a total of 4 solutions. If we have access to the
 * sets of points visible in the camera frame before and after the homography transformation is applied,
 * we can determine which are the true potential solutions and which are the opposites by verifying which
 * homographies are consistent with all visible reference points being in front of the camera. The inputs
 * are left unchanged; the filtered solution set is returned as indices into the existing one.
 */
+ (void)filterHomographyDecompByVisibleRefpoints:(NSArray<Mat*>*)rotations normals:(NSArray<Mat*>*)normals beforePoints:(Mat*)beforePoints afterPoints:(Mat*)afterPoints possibleSolutions:(Mat*)possibleSolutions pointsMask:(Mat*)pointsMask NS_SWIFT_NAME(filterHomographyDecompByVisibleRefpoints(rotations:normals:beforePoints:afterPoints:possibleSolutions:pointsMask:));

/**
 * Filters homography decompositions based on additional information.
 *
 * @param rotations Vector of rotation matrices.
 * @param normals Vector of plane normal matrices.
 * @param beforePoints Vector of (rectified) visible reference points before the homography is applied
 * @param afterPoints Vector of (rectified) visible reference points after the homography is applied
 * @param possibleSolutions Vector of int indices representing the viable solution set after filtering
 *
 * This function is intended to filter the output of the #decomposeHomographyMat based on additional
 * information as described in CITE: Malis . The summary of the method: the #decomposeHomographyMat function
 * returns 2 unique solutions and their "opposites" for a total of 4 solutions. If we have access to the
 * sets of points visible in the camera frame before and after the homography transformation is applied,
 * we can determine which are the true potential solutions and which are the opposites by verifying which
 * homographies are consistent with all visible reference points being in front of the camera. The inputs
 * are left unchanged; the filtered solution set is returned as indices into the existing one.
 */
+ (void)filterHomographyDecompByVisibleRefpoints:(NSArray<Mat*>*)rotations normals:(NSArray<Mat*>*)normals beforePoints:(Mat*)beforePoints afterPoints:(Mat*)afterPoints possibleSolutions:(Mat*)possibleSolutions NS_SWIFT_NAME(filterHomographyDecompByVisibleRefpoints(rotations:normals:beforePoints:afterPoints:possibleSolutions:));


//
//  void cv::undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat())
//
/**
 * Transforms an image to compensate for lens distortion.
 *
 * The function transforms an image to compensate radial and tangential lens distortion.
 *
 * The function is simply a combination of #initUndistortRectifyMap (with unity R ) and #remap
 * (with bilinear interpolation). See the former function for details of the transformation being
 * performed.
 *
 * Those pixels in the destination image, for which there is no correspondent pixels in the source
 * image, are filled with zeros (black color).
 *
 * A particular subset of the source image that will be visible in the corrected image can be regulated
 * by newCameraMatrix. You can use #getOptimalNewCameraMatrix to compute the appropriate
 * newCameraMatrix depending on your requirements.
 *
 * The camera matrix and the distortion parameters can be determined using #calibrateCamera. If
 * the resolution of images is different from the resolution used at the calibration stage, `$$f_x,
 * f_y, c_x$$` and `$$c_y$$` need to be scaled accordingly, while the distortion coefficients remain
 * the same.
 *
 * @param src Input (distorted) image.
 * @param dst Output (corrected) image that has the same size and type as src .
 * @param cameraMatrix Input camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param newCameraMatrix Camera matrix of the distorted image. By default, it is the same as
 * cameraMatrix but you may additionally scale and shift the result by using a different matrix.
 */
+ (void)undistort:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs newCameraMatrix:(Mat*)newCameraMatrix NS_SWIFT_NAME(undistort(src:dst:cameraMatrix:distCoeffs:newCameraMatrix:));

/**
 * Transforms an image to compensate for lens distortion.
 *
 * The function transforms an image to compensate radial and tangential lens distortion.
 *
 * The function is simply a combination of #initUndistortRectifyMap (with unity R ) and #remap
 * (with bilinear interpolation). See the former function for details of the transformation being
 * performed.
 *
 * Those pixels in the destination image, for which there is no correspondent pixels in the source
 * image, are filled with zeros (black color).
 *
 * A particular subset of the source image that will be visible in the corrected image can be regulated
 * by newCameraMatrix. You can use #getOptimalNewCameraMatrix to compute the appropriate
 * newCameraMatrix depending on your requirements.
 *
 * The camera matrix and the distortion parameters can be determined using #calibrateCamera. If
 * the resolution of images is different from the resolution used at the calibration stage, `$$f_x,
 * f_y, c_x$$` and `$$c_y$$` need to be scaled accordingly, while the distortion coefficients remain
 * the same.
 *
 * @param src Input (distorted) image.
 * @param dst Output (corrected) image that has the same size and type as src .
 * @param cameraMatrix Input camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * cameraMatrix but you may additionally scale and shift the result by using a different matrix.
 */
+ (void)undistort:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs NS_SWIFT_NAME(undistort(src:dst:cameraMatrix:distCoeffs:));


//
//  void cv::initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2)
//
/**
 * Computes the undistortion and rectification transformation map.
 *
 * The function computes the joint undistortion and rectification transformation and represents the
 * result in the form of maps for #remap. The undistorted image looks like original, as if it is
 * captured with a camera using the camera matrix =newCameraMatrix and zero distortion. In case of a
 * monocular camera, newCameraMatrix is usually equal to cameraMatrix, or it can be computed by
 * #getOptimalNewCameraMatrix for a better control over scaling. In case of a stereo camera,
 * newCameraMatrix is normally set to P1 or P2 computed by #stereoRectify .
 *
 * Also, this new camera is oriented differently in the coordinate space, according to R. That, for
 * example, helps to align two heads of a stereo camera so that the epipolar lines on both images
 * become horizontal and have the same y- coordinate (in case of a horizontally aligned stereo camera).
 *
 * The function actually builds the maps for the inverse mapping algorithm that is used by #remap. That
 * is, for each pixel `$$(u, v)$$` in the destination (corrected and rectified) image, the function
 * computes the corresponding coordinates in the source image (that is, in the original image from
 * camera). The following process is applied:
 * `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } 
 * \begin{array}{l}
 * x  \leftarrow (u - {c'}_x)/{f'}_x  \\
 * y  \leftarrow (v - {c'}_y)/{f'}_y  \\
 * {[X\,Y\,W]} ^T  \leftarrow R^{-1}*[x \, y \, 1]^T  \\
 * x'  \leftarrow X/W  \\
 * y'  \leftarrow Y/W  \\
 * r^2  \leftarrow x'^2 + y'^2 \\
 * x''  \leftarrow x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}
 * + 2p_1 x' y' + p_2(r^2 + 2 x'^2)  + s_1 r^2 + s_2 r^4\\
 * y''  \leftarrow y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}
 * + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\
 * s\vecthree{x'''}{y'''}{1} =
 * \vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}((\tau_x, \tau_y)}
 * {0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)}
 * {0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\\
 * map_x(u,v)  \leftarrow x''' f_x + c_x  \\
 * map_y(u,v)  \leftarrow y''' f_y + c_y
 * \end{array}
 * $$`
 * where `$$(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]]]])$$`
 * are the distortion coefficients.
 *
 * In case of a stereo camera, this function is called twice: once for each camera head, after
 * #stereoRectify, which in its turn is called after #stereoCalibrate. But if the stereo camera
 * was not calibrated, it is still possible to compute the rectification transformations directly from
 * the fundamental matrix using #stereoRectifyUncalibrated. For each camera, the function computes
 * homography H as the rectification transformation in a pixel domain, not a rotation matrix R in 3D
 * space. R can be computed from H as
 * `$$\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}$$`
 * where cameraMatrix can be chosen arbitrarily.
 *
 * @param cameraMatrix Input camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param R Optional rectification transformation in the object space (3x3 matrix). R1 or R2 ,
 * computed by #stereoRectify can be passed here. If the matrix is empty, the identity transformation
 * is assumed. In cvInitUndistortMap R assumed to be an identity matrix.
 * @param newCameraMatrix New camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}$$`.
 * @param size Undistorted image size.
 * @param m1type Type of the first output map that can be CV_32FC1, CV_32FC2 or CV_16SC2, see #convertMaps
 * @param map1 The first output map.
 * @param map2 The second output map.
 */
+ (void)initUndistortRectifyMap:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs R:(Mat*)R newCameraMatrix:(Mat*)newCameraMatrix size:(Size2i*)size m1type:(int)m1type map1:(Mat*)map1 map2:(Mat*)map2 NS_SWIFT_NAME(initUndistortRectifyMap(cameraMatrix:distCoeffs:R:newCameraMatrix:size:m1type:map1:map2:));


//
//  void cv::initInverseRectificationMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2)
//
/**
 * Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of
 * #initUndistortRectifyMap to accomodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs.
 *
 * The function computes the joint projection and inverse rectification transformation and represents the
 * result in the form of maps for #remap. The projected image looks like a distorted version of the original which,
 * once projected by a projector, should visually match the original. In case of a monocular camera, newCameraMatrix
 * is usually equal to cameraMatrix, or it can be computed by
 * #getOptimalNewCameraMatrix for a better control over scaling. In case of a projector-camera pair,
 * newCameraMatrix is normally set to P1 or P2 computed by #stereoRectify .
 *
 * The projector is oriented differently in the coordinate space, according to R. In case of projector-camera pairs,
 * this helps align the projector (in the same manner as #initUndistortRectifyMap for the camera) to create a stereo-rectified pair. This
 * allows epipolar lines on both images to become horizontal and have the same y-coordinate (in case of a horizontally aligned projector-camera pair).
 *
 * The function builds the maps for the inverse mapping algorithm that is used by #remap. That
 * is, for each pixel `$$(u, v)$$` in the destination (projected and inverse-rectified) image, the function
 * computes the corresponding coordinates in the source image (that is, in the original digital image). The following process is applied:
 *
 * `$$
 * \begin{array}{l}
 * \text{newCameraMatrix}\\
 * x  \leftarrow (u - {c'}_x)/{f'}_x  \\
 * y  \leftarrow (v - {c'}_y)/{f'}_y  \\
 *
 * \\\text{Undistortion}
 * \\\scriptsize{\textit{though equation shown is for radial undistortion, function implements cv::undistortPoints()}}\\
 * r^2  \leftarrow x^2 + y^2 \\
 * \theta \leftarrow \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}\\
 * x' \leftarrow \frac{x}{\theta} \\
 * y'  \leftarrow \frac{y}{\theta} \\
 *
 * \\\text{Rectification}\\
 * {[X\,Y\,W]} ^T  \leftarrow R*[x' \, y' \, 1]^T  \\
 * x''  \leftarrow X/W  \\
 * y''  \leftarrow Y/W  \\
 *
 * \\\text{cameraMatrix}\\
 * map_x(u,v)  \leftarrow x'' f_x + c_x  \\
 * map_y(u,v)  \leftarrow y'' f_y + c_y
 * \end{array}
 * $$`
 * where `$$(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]]]])$$`
 * are the distortion coefficients vector distCoeffs.
 *
 * In case of a stereo-rectified projector-camera pair, this function is called for the projector while #initUndistortRectifyMap is called for the camera head.
 * This is done after #stereoRectify, which in turn is called after #stereoCalibrate. If the projector-camera pair
 * is not calibrated, it is still possible to compute the rectification transformations directly from
 * the fundamental matrix using #stereoRectifyUncalibrated. For the projector and camera, the function computes
 * homography H as the rectification transformation in a pixel domain, not a rotation matrix R in 3D
 * space. R can be computed from H as
 * `$$\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}$$`
 * where cameraMatrix can be chosen arbitrarily.
 *
 * @param cameraMatrix Input camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param R Optional rectification transformation in the object space (3x3 matrix). R1 or R2,
 * computed by #stereoRectify can be passed here. If the matrix is empty, the identity transformation
 * is assumed.
 * @param newCameraMatrix New camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}$$`.
 * @param size Distorted image size.
 * @param m1type Type of the first output map. Can be CV_32FC1, CV_32FC2 or CV_16SC2, see #convertMaps
 * @param map1 The first output map for #remap.
 * @param map2 The second output map for #remap.
 */
+ (void)initInverseRectificationMap:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs R:(Mat*)R newCameraMatrix:(Mat*)newCameraMatrix size:(Size2i*)size m1type:(int)m1type map1:(Mat*)map1 map2:(Mat*)map2 NS_SWIFT_NAME(initInverseRectificationMap(cameraMatrix:distCoeffs:R:newCameraMatrix:size:m1type:map1:map2:));


//
//  Mat cv::getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false)
//
/**
 * Returns the default new camera matrix.
 *
 * The function returns the camera matrix that is either an exact copy of the input cameraMatrix (when
 * centerPrinicipalPoint=false ), or the modified one (when centerPrincipalPoint=true).
 *
 * In the latter case, the new camera matrix will be:
 *
 * `$$\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5  \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5  \\ 0 && 0 && 1 \end{bmatrix} ,$$`
 *
 * where `$$f_x$$` and `$$f_y$$` are `$$(0,0)$$` and `$$(1,1)$$` elements of cameraMatrix, respectively.
 *
 * By default, the undistortion functions in OpenCV (see #initUndistortRectifyMap, #undistort) do not
 * move the principal point. However, when you work with stereo, it is important to move the principal
 * points in both views to the same y-coordinate (which is required by most of stereo correspondence
 * algorithms), and may be to the same x-coordinate too. So, you can form the new camera matrix for
 * each view where the principal points are located at the center.
 *
 * @param cameraMatrix Input camera matrix.
 * @param imgsize Camera view image size in pixels.
 * @param centerPrincipalPoint Location of the principal point in the new camera matrix. The
 * parameter indicates whether this location should be at the image center or not.
 */
+ (Mat*)getDefaultNewCameraMatrix:(Mat*)cameraMatrix imgsize:(Size2i*)imgsize centerPrincipalPoint:(BOOL)centerPrincipalPoint NS_SWIFT_NAME(getDefaultNewCameraMatrix(cameraMatrix:imgsize:centerPrincipalPoint:));

/**
 * Returns the default new camera matrix.
 *
 * The function returns the camera matrix that is either an exact copy of the input cameraMatrix (when
 * centerPrinicipalPoint=false ), or the modified one (when centerPrincipalPoint=true).
 *
 * In the latter case, the new camera matrix will be:
 *
 * `$$\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5  \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5  \\ 0 && 0 && 1 \end{bmatrix} ,$$`
 *
 * where `$$f_x$$` and `$$f_y$$` are `$$(0,0)$$` and `$$(1,1)$$` elements of cameraMatrix, respectively.
 *
 * By default, the undistortion functions in OpenCV (see #initUndistortRectifyMap, #undistort) do not
 * move the principal point. However, when you work with stereo, it is important to move the principal
 * points in both views to the same y-coordinate (which is required by most of stereo correspondence
 * algorithms), and may be to the same x-coordinate too. So, you can form the new camera matrix for
 * each view where the principal points are located at the center.
 *
 * @param cameraMatrix Input camera matrix.
 * @param imgsize Camera view image size in pixels.
 * parameter indicates whether this location should be at the image center or not.
 */
+ (Mat*)getDefaultNewCameraMatrix:(Mat*)cameraMatrix imgsize:(Size2i*)imgsize NS_SWIFT_NAME(getDefaultNewCameraMatrix(cameraMatrix:imgsize:));

/**
 * Returns the default new camera matrix.
 *
 * The function returns the camera matrix that is either an exact copy of the input cameraMatrix (when
 * centerPrinicipalPoint=false ), or the modified one (when centerPrincipalPoint=true).
 *
 * In the latter case, the new camera matrix will be:
 *
 * `$$\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5  \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5  \\ 0 && 0 && 1 \end{bmatrix} ,$$`
 *
 * where `$$f_x$$` and `$$f_y$$` are `$$(0,0)$$` and `$$(1,1)$$` elements of cameraMatrix, respectively.
 *
 * By default, the undistortion functions in OpenCV (see #initUndistortRectifyMap, #undistort) do not
 * move the principal point. However, when you work with stereo, it is important to move the principal
 * points in both views to the same y-coordinate (which is required by most of stereo correspondence
 * algorithms), and may be to the same x-coordinate too. So, you can form the new camera matrix for
 * each view where the principal points are located at the center.
 *
 * @param cameraMatrix Input camera matrix.
 * parameter indicates whether this location should be at the image center or not.
 */
+ (Mat*)getDefaultNewCameraMatrix:(Mat*)cameraMatrix NS_SWIFT_NAME(getDefaultNewCameraMatrix(cameraMatrix:));


//
//  void cv::undistortPoints(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat())
//
/**
 * Computes the ideal point coordinates from the observed point coordinates.
 *
 * The function is similar to #undistort and #initUndistortRectifyMap but it operates on a
 * sparse set of points instead of a raster image. Also the function performs a reverse transformation
 * to  #projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a
 * planar object, it does, up to a translation vector, if the proper R is specified.
 *
 * For each observed point coordinate `$$(u, v)$$` the function computes:
 * `$$
 * \begin{array}{l}
 * x^{"}  \leftarrow (u - c_x)/f_x  \\
 * y^{"}  \leftarrow (v - c_y)/f_y  \\
 * (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\
 * {[X\,Y\,W]} ^T  \leftarrow R*[x' \, y' \, 1]^T  \\
 * x  \leftarrow X/W  \\
 * y  \leftarrow Y/W  \\
 * \text{only performed if P is specified:} \\
 * u'  \leftarrow x {f'}_x + {c'}_x  \\
 * v'  \leftarrow y {f'}_y + {c'}_y
 * \end{array}
 * $$`
 *
 * where *undistort* is an approximate iterative algorithm that estimates the normalized original
 * point coordinates out of the normalized distorted point coordinates ("normalized" means that the
 * coordinates do not depend on the camera matrix).
 *
 * The function can be used for both a stereo camera head or a monocular camera (when R is empty).
 * @param src Observed point coordinates, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel (CV_32FC2 or CV_64FC2) (or
 * vector\<Point2f\> ).
 * @param dst Output ideal point coordinates (1xN/Nx1 2-channel or vector\<Point2f\> ) after undistortion and reverse perspective
 * transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates.
 * @param cameraMatrix Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param R Rectification transformation in the object space (3x3 matrix). R1 or R2 computed by
 * #stereoRectify can be passed here. If the matrix is empty, the identity transformation is used.
 * @param P New camera matrix (3x3) or new projection matrix (3x4) `$$\begin{bmatrix} {f'}_x & 0 & {c'}_x & t_x \\ 0 & {f'}_y & {c'}_y & t_y \\ 0 & 0 & 1 & t_z \end{bmatrix}$$`. P1 or P2 computed by
 * #stereoRectify can be passed here. If the matrix is empty, the identity new camera matrix is used.
 */
+ (void)undistortPoints:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs R:(Mat*)R P:(Mat*)P NS_SWIFT_NAME(undistortPoints(src:dst:cameraMatrix:distCoeffs:R:P:));

/**
 * Computes the ideal point coordinates from the observed point coordinates.
 *
 * The function is similar to #undistort and #initUndistortRectifyMap but it operates on a
 * sparse set of points instead of a raster image. Also the function performs a reverse transformation
 * to  #projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a
 * planar object, it does, up to a translation vector, if the proper R is specified.
 *
 * For each observed point coordinate `$$(u, v)$$` the function computes:
 * `$$
 * \begin{array}{l}
 * x^{"}  \leftarrow (u - c_x)/f_x  \\
 * y^{"}  \leftarrow (v - c_y)/f_y  \\
 * (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\
 * {[X\,Y\,W]} ^T  \leftarrow R*[x' \, y' \, 1]^T  \\
 * x  \leftarrow X/W  \\
 * y  \leftarrow Y/W  \\
 * \text{only performed if P is specified:} \\
 * u'  \leftarrow x {f'}_x + {c'}_x  \\
 * v'  \leftarrow y {f'}_y + {c'}_y
 * \end{array}
 * $$`
 *
 * where *undistort* is an approximate iterative algorithm that estimates the normalized original
 * point coordinates out of the normalized distorted point coordinates ("normalized" means that the
 * coordinates do not depend on the camera matrix).
 *
 * The function can be used for both a stereo camera head or a monocular camera (when R is empty).
 * @param src Observed point coordinates, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel (CV_32FC2 or CV_64FC2) (or
 * vector\<Point2f\> ).
 * @param dst Output ideal point coordinates (1xN/Nx1 2-channel or vector\<Point2f\> ) after undistortion and reverse perspective
 * transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates.
 * @param cameraMatrix Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * @param R Rectification transformation in the object space (3x3 matrix). R1 or R2 computed by
 * #stereoRectify can be passed here. If the matrix is empty, the identity transformation is used.
 * #stereoRectify can be passed here. If the matrix is empty, the identity new camera matrix is used.
 */
+ (void)undistortPoints:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs R:(Mat*)R NS_SWIFT_NAME(undistortPoints(src:dst:cameraMatrix:distCoeffs:R:));

/**
 * Computes the ideal point coordinates from the observed point coordinates.
 *
 * The function is similar to #undistort and #initUndistortRectifyMap but it operates on a
 * sparse set of points instead of a raster image. Also the function performs a reverse transformation
 * to  #projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a
 * planar object, it does, up to a translation vector, if the proper R is specified.
 *
 * For each observed point coordinate `$$(u, v)$$` the function computes:
 * `$$
 * \begin{array}{l}
 * x^{"}  \leftarrow (u - c_x)/f_x  \\
 * y^{"}  \leftarrow (v - c_y)/f_y  \\
 * (x',y') = undistort(x^{"},y^{"}, \texttt{distCoeffs}) \\
 * {[X\,Y\,W]} ^T  \leftarrow R*[x' \, y' \, 1]^T  \\
 * x  \leftarrow X/W  \\
 * y  \leftarrow Y/W  \\
 * \text{only performed if P is specified:} \\
 * u'  \leftarrow x {f'}_x + {c'}_x  \\
 * v'  \leftarrow y {f'}_y + {c'}_y
 * \end{array}
 * $$`
 *
 * where *undistort* is an approximate iterative algorithm that estimates the normalized original
 * point coordinates out of the normalized distorted point coordinates ("normalized" means that the
 * coordinates do not depend on the camera matrix).
 *
 * The function can be used for both a stereo camera head or a monocular camera (when R is empty).
 * @param src Observed point coordinates, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel (CV_32FC2 or CV_64FC2) (or
 * vector\<Point2f\> ).
 * @param dst Output ideal point coordinates (1xN/Nx1 2-channel or vector\<Point2f\> ) after undistortion and reverse perspective
 * transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates.
 * @param cameraMatrix Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Input 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[, \tau_x, \tau_y]]]])$$`
 * of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 * #stereoRectify can be passed here. If the matrix is empty, the identity transformation is used.
 * #stereoRectify can be passed here. If the matrix is empty, the identity new camera matrix is used.
 */
+ (void)undistortPoints:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs NS_SWIFT_NAME(undistortPoints(src:dst:cameraMatrix:distCoeffs:));


//
//  void cv::undistortPoints(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P, TermCriteria criteria)
//
/**
 *
 *     NOTE: Default version of #undistortPoints does 5 iterations to compute undistorted points.
 */
+ (void)undistortPointsIter:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs R:(Mat*)R P:(Mat*)P criteria:(TermCriteria*)criteria NS_SWIFT_NAME(undistortPoints(src:dst:cameraMatrix:distCoeffs:R:P:criteria:));


//
//  void cv::undistortImagePoints(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, TermCriteria arg1 = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 0.01))
//
/**
 * Compute undistorted image points position
 *
 * @param src Observed points position, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel (CV_32FC2 or
 * CV_64FC2) (or vector\<Point2f\> ).
 * @param dst Output undistorted points position (1xN/Nx1 2-channel or vector\<Point2f\> ).
 * @param cameraMatrix Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Distortion coefficients
 */
+ (void)undistortImagePoints:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs arg1:(TermCriteria*)arg1 NS_SWIFT_NAME(undistortImagePoints(src:dst:cameraMatrix:distCoeffs:arg1:));

/**
 * Compute undistorted image points position
 *
 * @param src Observed points position, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel (CV_32FC2 or
 * CV_64FC2) (or vector\<Point2f\> ).
 * @param dst Output undistorted points position (1xN/Nx1 2-channel or vector\<Point2f\> ).
 * @param cameraMatrix Camera matrix `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$$` .
 * @param distCoeffs Distortion coefficients
 */
+ (void)undistortImagePoints:(Mat*)src dst:(Mat*)dst cameraMatrix:(Mat*)cameraMatrix distCoeffs:(Mat*)distCoeffs NS_SWIFT_NAME(undistortImagePoints(src:dst:cameraMatrix:distCoeffs:));


//
//  void cv::fisheye::projectPoints(Mat objectPoints, Mat& imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha = 0, Mat& jacobian = Mat())
//
+ (void)projectPoints:(Mat*)objectPoints imagePoints:(Mat*)imagePoints rvec:(Mat*)rvec tvec:(Mat*)tvec K:(Mat*)K D:(Mat*)D alpha:(double)alpha jacobian:(Mat*)jacobian NS_SWIFT_NAME(projectPoints(objectPoints:imagePoints:rvec:tvec:K:D:alpha:jacobian:));

+ (void)projectPoints:(Mat*)objectPoints imagePoints:(Mat*)imagePoints rvec:(Mat*)rvec tvec:(Mat*)tvec K:(Mat*)K D:(Mat*)D alpha:(double)alpha NS_SWIFT_NAME(projectPoints(objectPoints:imagePoints:rvec:tvec:K:D:alpha:));

+ (void)projectPoints:(Mat*)objectPoints imagePoints:(Mat*)imagePoints rvec:(Mat*)rvec tvec:(Mat*)tvec K:(Mat*)K D:(Mat*)D NS_SWIFT_NAME(projectPoints(objectPoints:imagePoints:rvec:tvec:K:D:));


//
//  void cv::fisheye::distortPoints(Mat undistorted, Mat& distorted, Mat K, Mat D, double alpha = 0)
//
/**
 * Distorts 2D points using fisheye model.
 *
 * @param undistorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is
 *     the number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param alpha The skew coefficient.
 * @param distorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 *
 *     Note that the function assumes the camera intrinsic matrix of the undistorted points to be identity.
 *     This means if you want to distort image points you have to multiply them with `$$K^{-1}$$`.
 */
+ (void)distortPoints:(Mat*)undistorted distorted:(Mat*)distorted K:(Mat*)K D:(Mat*)D alpha:(double)alpha NS_SWIFT_NAME(distortPoints(undistorted:distorted:K:D:alpha:));

/**
 * Distorts 2D points using fisheye model.
 *
 * @param undistorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is
 *     the number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param distorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 *
 *     Note that the function assumes the camera intrinsic matrix of the undistorted points to be identity.
 *     This means if you want to distort image points you have to multiply them with `$$K^{-1}$$`.
 */
+ (void)distortPoints:(Mat*)undistorted distorted:(Mat*)distorted K:(Mat*)K D:(Mat*)D NS_SWIFT_NAME(distortPoints(undistorted:distorted:K:D:));


//
//  void cv::fisheye::undistortPoints(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat R = Mat(), Mat P = Mat(), TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 10, 1e-8))
//
/**
 * Undistorts 2D points using fisheye model
 *
 * @param distorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is the
 *     number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param criteria Termination criteria
 * @param undistorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 */
+ (void)undistortPoints:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D R:(Mat*)R P:(Mat*)P criteria:(TermCriteria*)criteria NS_SWIFT_NAME(undistortPoints(distorted:undistorted:K:D:R:P:criteria:));

/**
 * Undistorts 2D points using fisheye model
 *
 * @param distorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is the
 *     number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param undistorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 */
+ (void)undistortPoints:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D R:(Mat*)R P:(Mat*)P NS_SWIFT_NAME(undistortPoints(distorted:undistorted:K:D:R:P:));

/**
 * Undistorts 2D points using fisheye model
 *
 * @param distorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is the
 *     number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param undistorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 */
+ (void)undistortPoints:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D R:(Mat*)R NS_SWIFT_NAME(undistortPoints(distorted:undistorted:K:D:R:));

/**
 * Undistorts 2D points using fisheye model
 *
 * @param distorted Array of object points, 1xN/Nx1 2-channel (or vector\<Point2f\> ), where N is the
 *     number of points in the view.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 *     1-channel or 1x1 3-channel
 * @param undistorted Output array of image points, 1xN/Nx1 2-channel, or vector\<Point2f\> .
 */
+ (void)undistortPoints:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D NS_SWIFT_NAME(undistortPoints(distorted:undistorted:K:D:));


//
//  void cv::fisheye::initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat& map1, Mat& map2)
//
/**
 * Computes undistortion and rectification maps for image transform by #remap. If D is empty zero
 *     distortion is used, if R or P is empty identity matrixes are used.
 *
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param size Undistorted image size.
 * @param m1type Type of the first output map that can be CV_32FC1 or CV_16SC2 . See #convertMaps
 *     for details.
 * @param map1 The first output map.
 * @param map2 The second output map.
 */
+ (void)initUndistortRectifyMap:(Mat*)K D:(Mat*)D R:(Mat*)R P:(Mat*)P size:(Size2i*)size m1type:(int)m1type map1:(Mat*)map1 map2:(Mat*)map2 NS_SWIFT_NAME(initUndistortRectifyMap(K:D:R:P:size:m1type:map1:map2:));


//
//  void cv::fisheye::undistortImage(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat Knew = cv::Mat(), Size new_size = Size())
//
/**
 * Transforms an image to compensate for fisheye lens distortion.
 *
 * @param distorted image with fisheye lens distortion.
 * @param undistorted Output image with compensated fisheye lens distortion.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param Knew Camera intrinsic matrix of the distorted image. By default, it is the identity matrix but you
 *     may additionally scale and shift the result by using a different matrix.
 * @param new_size the new size
 *
 *     The function transforms an image to compensate radial and tangential lens distortion.
 *
 *     The function is simply a combination of #fisheye::initUndistortRectifyMap (with unity R ) and #remap
 *     (with bilinear interpolation). See the former function for details of the transformation being
 *     performed.
 *
 *     See below the results of undistortImage.
 *        -   a\) result of undistort of perspective camera model (all possible coefficients (k_1, k_2, k_3,
 *             k_4, k_5, k_6) of distortion were optimized under calibration)
 *         -   b\) result of #fisheye::undistortImage of fisheye camera model (all possible coefficients (k_1, k_2,
 *             k_3, k_4) of fisheye distortion were optimized under calibration)
 *         -   c\) original image was captured with fisheye lens
 *
 *     Pictures a) and b) almost the same. But if we consider points of image located far from the center
 *     of image, we can notice that on image a) these points are distorted.
 *
 *     ![image](pics/fisheye_undistorted.jpg)
 */
+ (void)undistortImage:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D Knew:(Mat*)Knew new_size:(Size2i*)new_size NS_SWIFT_NAME(undistortImage(distorted:undistorted:K:D:Knew:new_size:));

/**
 * Transforms an image to compensate for fisheye lens distortion.
 *
 * @param distorted image with fisheye lens distortion.
 * @param undistorted Output image with compensated fisheye lens distortion.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param Knew Camera intrinsic matrix of the distorted image. By default, it is the identity matrix but you
 *     may additionally scale and shift the result by using a different matrix.
 *
 *     The function transforms an image to compensate radial and tangential lens distortion.
 *
 *     The function is simply a combination of #fisheye::initUndistortRectifyMap (with unity R ) and #remap
 *     (with bilinear interpolation). See the former function for details of the transformation being
 *     performed.
 *
 *     See below the results of undistortImage.
 *        -   a\) result of undistort of perspective camera model (all possible coefficients (k_1, k_2, k_3,
 *             k_4, k_5, k_6) of distortion were optimized under calibration)
 *         -   b\) result of #fisheye::undistortImage of fisheye camera model (all possible coefficients (k_1, k_2,
 *             k_3, k_4) of fisheye distortion were optimized under calibration)
 *         -   c\) original image was captured with fisheye lens
 *
 *     Pictures a) and b) almost the same. But if we consider points of image located far from the center
 *     of image, we can notice that on image a) these points are distorted.
 *
 *     ![image](pics/fisheye_undistorted.jpg)
 */
+ (void)undistortImage:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D Knew:(Mat*)Knew NS_SWIFT_NAME(undistortImage(distorted:undistorted:K:D:Knew:));

/**
 * Transforms an image to compensate for fisheye lens distortion.
 *
 * @param distorted image with fisheye lens distortion.
 * @param undistorted Output image with compensated fisheye lens distortion.
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 *     may additionally scale and shift the result by using a different matrix.
 *
 *     The function transforms an image to compensate radial and tangential lens distortion.
 *
 *     The function is simply a combination of #fisheye::initUndistortRectifyMap (with unity R ) and #remap
 *     (with bilinear interpolation). See the former function for details of the transformation being
 *     performed.
 *
 *     See below the results of undistortImage.
 *        -   a\) result of undistort of perspective camera model (all possible coefficients (k_1, k_2, k_3,
 *             k_4, k_5, k_6) of distortion were optimized under calibration)
 *         -   b\) result of #fisheye::undistortImage of fisheye camera model (all possible coefficients (k_1, k_2,
 *             k_3, k_4) of fisheye distortion were optimized under calibration)
 *         -   c\) original image was captured with fisheye lens
 *
 *     Pictures a) and b) almost the same. But if we consider points of image located far from the center
 *     of image, we can notice that on image a) these points are distorted.
 *
 *     ![image](pics/fisheye_undistorted.jpg)
 */
+ (void)undistortImage:(Mat*)distorted undistorted:(Mat*)undistorted K:(Mat*)K D:(Mat*)D NS_SWIFT_NAME(undistortImage(distorted:undistorted:K:D:));


//
//  void cv::fisheye::estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat& P, double balance = 0.0, Size new_size = Size(), double fov_scale = 1.0)
//
/**
 * Estimates new camera intrinsic matrix for undistortion or rectification.
 *
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param image_size Size of the image
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param balance Sets the new focal length in range between the min focal length and the max focal
 *     length. Balance is in range of [0, 1].
 * @param new_size the new size
 * @param fov_scale Divisor for new focal length.
 */
+ (void)estimateNewCameraMatrixForUndistortRectify:(Mat*)K D:(Mat*)D image_size:(Size2i*)image_size R:(Mat*)R P:(Mat*)P balance:(double)balance new_size:(Size2i*)new_size fov_scale:(double)fov_scale NS_SWIFT_NAME(estimateNewCameraMatrixForUndistortRectify(K:D:image_size:R:P:balance:new_size:fov_scale:));

/**
 * Estimates new camera intrinsic matrix for undistortion or rectification.
 *
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param image_size Size of the image
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param balance Sets the new focal length in range between the min focal length and the max focal
 *     length. Balance is in range of [0, 1].
 * @param new_size the new size
 */
+ (void)estimateNewCameraMatrixForUndistortRectify:(Mat*)K D:(Mat*)D image_size:(Size2i*)image_size R:(Mat*)R P:(Mat*)P balance:(double)balance new_size:(Size2i*)new_size NS_SWIFT_NAME(estimateNewCameraMatrixForUndistortRectify(K:D:image_size:R:P:balance:new_size:));

/**
 * Estimates new camera intrinsic matrix for undistortion or rectification.
 *
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param image_size Size of the image
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 * @param balance Sets the new focal length in range between the min focal length and the max focal
 *     length. Balance is in range of [0, 1].
 */
+ (void)estimateNewCameraMatrixForUndistortRectify:(Mat*)K D:(Mat*)D image_size:(Size2i*)image_size R:(Mat*)R P:(Mat*)P balance:(double)balance NS_SWIFT_NAME(estimateNewCameraMatrixForUndistortRectify(K:D:image_size:R:P:balance:));

/**
 * Estimates new camera intrinsic matrix for undistortion or rectification.
 *
 * @param K Camera intrinsic matrix `$$cameramatrix{K}$$`.
 * @param image_size Size of the image
 * @param D Input vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param R Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3
 *     1-channel or 1x1 3-channel
 * @param P New camera intrinsic matrix (3x3) or new projection matrix (3x4)
 *     length. Balance is in range of [0, 1].
 */
+ (void)estimateNewCameraMatrixForUndistortRectify:(Mat*)K D:(Mat*)D image_size:(Size2i*)image_size R:(Mat*)R P:(Mat*)P NS_SWIFT_NAME(estimateNewCameraMatrixForUndistortRectify(K:D:image_size:R:P:));


//
//  double cv::fisheye::calibrate(vector_Mat objectPoints, vector_Mat imagePoints, Size image_size, Mat& K, Mat& D, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
//
/**
 * Performs camera calibration
 *
 * @param objectPoints vector of vectors of calibration pattern points in the calibration pattern
 *     coordinate space.
 * @param imagePoints vector of vectors of the projections of calibration pattern points.
 *     imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to
 *     objectPoints[i].size() for each i.
 * @param image_size Size of the image used only to initialize the camera intrinsic matrix.
 * @param K Output 3x3 floating-point camera intrinsic matrix
 *     `$$\cameramatrix{A}$$` . If
 *     REF: fisheye::CALIB_USE_INTRINSIC_GUESS is specified, some or all of fx, fy, cx, cy must be
 *     initialized before calling the function.
 * @param D Output vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view.
 *     That is, each k-th rotation vector together with the corresponding k-th translation vector (see
 *     the next output parameter description) brings the calibration pattern from the model coordinate
 *     space (in which object points are specified) to the world coordinate space, that is, a real
 *     position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  cameraMatrix contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients
 *     are set to zeros and stay zero.
 *     -    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT  The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 *     -    REF: fisheye::CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global
 * optimization. It is the `$$max(width,height)/\pi$$` or the provided `$$f_x$$`, `$$f_y$$` when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 * @param criteria Termination criteria for the iterative optimization algorithm.
 */
+ (double)calibrate:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints image_size:(Size2i*)image_size K:(Mat*)K D:(Mat*)D rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(calibrate(objectPoints:imagePoints:image_size:K:D:rvecs:tvecs:flags:criteria:));

/**
 * Performs camera calibration
 *
 * @param objectPoints vector of vectors of calibration pattern points in the calibration pattern
 *     coordinate space.
 * @param imagePoints vector of vectors of the projections of calibration pattern points.
 *     imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to
 *     objectPoints[i].size() for each i.
 * @param image_size Size of the image used only to initialize the camera intrinsic matrix.
 * @param K Output 3x3 floating-point camera intrinsic matrix
 *     `$$\cameramatrix{A}$$` . If
 *     REF: fisheye::CALIB_USE_INTRINSIC_GUESS is specified, some or all of fx, fy, cx, cy must be
 *     initialized before calling the function.
 * @param D Output vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view.
 *     That is, each k-th rotation vector together with the corresponding k-th translation vector (see
 *     the next output parameter description) brings the calibration pattern from the model coordinate
 *     space (in which object points are specified) to the world coordinate space, that is, a real
 *     position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 * @param flags Different flags that may be zero or a combination of the following values:
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  cameraMatrix contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients
 *     are set to zeros and stay zero.
 *     -    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT  The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 *     -    REF: fisheye::CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global
 * optimization. It is the `$$max(width,height)/\pi$$` or the provided `$$f_x$$`, `$$f_y$$` when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 */
+ (double)calibrate:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints image_size:(Size2i*)image_size K:(Mat*)K D:(Mat*)D rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs flags:(int)flags NS_SWIFT_NAME(calibrate(objectPoints:imagePoints:image_size:K:D:rvecs:tvecs:flags:));

/**
 * Performs camera calibration
 *
 * @param objectPoints vector of vectors of calibration pattern points in the calibration pattern
 *     coordinate space.
 * @param imagePoints vector of vectors of the projections of calibration pattern points.
 *     imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to
 *     objectPoints[i].size() for each i.
 * @param image_size Size of the image used only to initialize the camera intrinsic matrix.
 * @param K Output 3x3 floating-point camera intrinsic matrix
 *     `$$\cameramatrix{A}$$` . If
 *     REF: fisheye::CALIB_USE_INTRINSIC_GUESS is specified, some or all of fx, fy, cx, cy must be
 *     initialized before calling the function.
 * @param D Output vector of distortion coefficients `$$\distcoeffsfisheye$$`.
 * @param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view.
 *     That is, each k-th rotation vector together with the corresponding k-th translation vector (see
 *     the next output parameter description) brings the calibration pattern from the model coordinate
 *     space (in which object points are specified) to the world coordinate space, that is, a real
 *     position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).
 * @param tvecs Output vector of translation vectors estimated for each pattern view.
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  cameraMatrix contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center ( imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -    REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients
 *     are set to zeros and stay zero.
 *     -    REF: fisheye::CALIB_FIX_PRINCIPAL_POINT  The principal point is not changed during the global
 * optimization. It stays at the center or at a different location specified when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 *     -    REF: fisheye::CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global
 * optimization. It is the `$$max(width,height)/\pi$$` or the provided `$$f_x$$`, `$$f_y$$` when REF: fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
 */
+ (double)calibrate:(NSArray<Mat*>*)objectPoints imagePoints:(NSArray<Mat*>*)imagePoints image_size:(Size2i*)image_size K:(Mat*)K D:(Mat*)D rvecs:(NSMutableArray<Mat*>*)rvecs tvecs:(NSMutableArray<Mat*>*)tvecs NS_SWIFT_NAME(calibrate(objectPoints:imagePoints:image_size:K:D:rvecs:tvecs:));


//
//  void cv::fisheye::stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags, Size newImageSize = Size(), double balance = 0.0, double fov_scale = 1.0)
//
/**
 * Stereo rectification for fisheye camera model
 *
 * @param K1 First camera intrinsic matrix.
 * @param D1 First camera distortion parameters.
 * @param K2 Second camera intrinsic matrix.
 * @param D2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix between the coordinate systems of the first and the second
 *     cameras.
 * @param tvec Translation vector between coordinate systems of the cameras.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 *     camera.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 *     camera.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see reprojectImageTo3D ).
 * @param flags Operation flags that may be zero or REF: fisheye::CALIB_ZERO_DISPARITY . If the flag is set,
 *     the function makes the principal points of each camera have the same pixel coordinates in the
 *     rectified views. And if the flag is not set, the function may still shift the images in the
 *     horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 *     useful image area.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 *     #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 *     is passed (default), it is set to the original imageSize . Setting it to larger value can help you
 *     preserve details in the original image, especially when there is a big radial distortion.
 * @param balance Sets the new focal length in range between the min focal length and the max focal
 *     length. Balance is in range of [0, 1].
 * @param fov_scale Divisor for new focal length.
 */
+ (void)stereoRectify:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R tvec:(Mat*)tvec R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags newImageSize:(Size2i*)newImageSize balance:(double)balance fov_scale:(double)fov_scale NS_SWIFT_NAME(stereoRectify(K1:D1:K2:D2:imageSize:R:tvec:R1:R2:P1:P2:Q:flags:newImageSize:balance:fov_scale:));

/**
 * Stereo rectification for fisheye camera model
 *
 * @param K1 First camera intrinsic matrix.
 * @param D1 First camera distortion parameters.
 * @param K2 Second camera intrinsic matrix.
 * @param D2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix between the coordinate systems of the first and the second
 *     cameras.
 * @param tvec Translation vector between coordinate systems of the cameras.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 *     camera.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 *     camera.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see reprojectImageTo3D ).
 * @param flags Operation flags that may be zero or REF: fisheye::CALIB_ZERO_DISPARITY . If the flag is set,
 *     the function makes the principal points of each camera have the same pixel coordinates in the
 *     rectified views. And if the flag is not set, the function may still shift the images in the
 *     horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 *     useful image area.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 *     #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 *     is passed (default), it is set to the original imageSize . Setting it to larger value can help you
 *     preserve details in the original image, especially when there is a big radial distortion.
 * @param balance Sets the new focal length in range between the min focal length and the max focal
 *     length. Balance is in range of [0, 1].
 */
+ (void)stereoRectify:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R tvec:(Mat*)tvec R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags newImageSize:(Size2i*)newImageSize balance:(double)balance NS_SWIFT_NAME(stereoRectify(K1:D1:K2:D2:imageSize:R:tvec:R1:R2:P1:P2:Q:flags:newImageSize:balance:));

/**
 * Stereo rectification for fisheye camera model
 *
 * @param K1 First camera intrinsic matrix.
 * @param D1 First camera distortion parameters.
 * @param K2 Second camera intrinsic matrix.
 * @param D2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix between the coordinate systems of the first and the second
 *     cameras.
 * @param tvec Translation vector between coordinate systems of the cameras.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 *     camera.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 *     camera.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see reprojectImageTo3D ).
 * @param flags Operation flags that may be zero or REF: fisheye::CALIB_ZERO_DISPARITY . If the flag is set,
 *     the function makes the principal points of each camera have the same pixel coordinates in the
 *     rectified views. And if the flag is not set, the function may still shift the images in the
 *     horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 *     useful image area.
 * @param newImageSize New image resolution after rectification. The same size should be passed to
 *     #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 *     is passed (default), it is set to the original imageSize . Setting it to larger value can help you
 *     preserve details in the original image, especially when there is a big radial distortion.
 *     length. Balance is in range of [0, 1].
 */
+ (void)stereoRectify:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R tvec:(Mat*)tvec R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags newImageSize:(Size2i*)newImageSize NS_SWIFT_NAME(stereoRectify(K1:D1:K2:D2:imageSize:R:tvec:R1:R2:P1:P2:Q:flags:newImageSize:));

/**
 * Stereo rectification for fisheye camera model
 *
 * @param K1 First camera intrinsic matrix.
 * @param D1 First camera distortion parameters.
 * @param K2 Second camera intrinsic matrix.
 * @param D2 Second camera distortion parameters.
 * @param imageSize Size of the image used for stereo calibration.
 * @param R Rotation matrix between the coordinate systems of the first and the second
 *     cameras.
 * @param tvec Translation vector between coordinate systems of the cameras.
 * @param R1 Output 3x3 rectification transform (rotation matrix) for the first camera.
 * @param R2 Output 3x3 rectification transform (rotation matrix) for the second camera.
 * @param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
 *     camera.
 * @param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
 *     camera.
 * @param Q Output `$$4 \times 4$$` disparity-to-depth mapping matrix (see reprojectImageTo3D ).
 * @param flags Operation flags that may be zero or REF: fisheye::CALIB_ZERO_DISPARITY . If the flag is set,
 *     the function makes the principal points of each camera have the same pixel coordinates in the
 *     rectified views. And if the flag is not set, the function may still shift the images in the
 *     horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
 *     useful image area.
 *     #initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
 *     is passed (default), it is set to the original imageSize . Setting it to larger value can help you
 *     preserve details in the original image, especially when there is a big radial distortion.
 *     length. Balance is in range of [0, 1].
 */
+ (void)stereoRectify:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R tvec:(Mat*)tvec R1:(Mat*)R1 R2:(Mat*)R2 P1:(Mat*)P1 P2:(Mat*)P2 Q:(Mat*)Q flags:(int)flags NS_SWIFT_NAME(stereoRectify(K1:D1:K2:D2:imageSize:R:tvec:R1:R2:P1:P2:Q:flags:));


//
//  double cv::fisheye::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& K1, Mat& D1, Mat& K2, Mat& D2, Size imageSize, Mat& R, Mat& T, int flags = fisheye::CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
//
/**
 * Performs stereo calibration
 *
 * @param objectPoints Vector of vectors of the calibration pattern points.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the first camera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the second camera.
 * @param K1 Input/output first camera intrinsic matrix:
 *     `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}$$` , `$$j = 0,\, 1$$` . If
 *     any of REF: fisheye::CALIB_USE_INTRINSIC_GUESS , REF: fisheye::CALIB_FIX_INTRINSIC are specified,
 *     some or all of the matrix components must be initialized.
 * @param D1 Input/output vector of distortion coefficients `$$\distcoeffsfisheye$$` of 4 elements.
 * @param K2 Input/output second camera intrinsic matrix. The parameter is similar to K1 .
 * @param D2 Input/output lens distortion coefficients for the second camera. The parameter is
 *     similar to D1 .
 * @param imageSize Size of the image used only to initialize camera intrinsic matrix.
 * @param R Output rotation matrix between the 1st and the 2nd camera coordinate systems.
 * @param T Output translation vector between the coordinate systems of the cameras.
 * @param flags Different flags that may be zero or a combination of the following values:
 *     -    REF: fisheye::CALIB_FIX_INTRINSIC  Fix K1, K2? and D1, D2? so that only R, T matrices
 *     are estimated.
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  K1, K2 contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center (imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -   REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay
 *     zero.
 * @param criteria Termination criteria for the iterative optimization algorithm.
 */
+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 K1:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T flags:(int)flags criteria:(TermCriteria*)criteria NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:K1:D1:K2:D2:imageSize:R:T:flags:criteria:));

/**
 * Performs stereo calibration
 *
 * @param objectPoints Vector of vectors of the calibration pattern points.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the first camera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the second camera.
 * @param K1 Input/output first camera intrinsic matrix:
 *     `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}$$` , `$$j = 0,\, 1$$` . If
 *     any of REF: fisheye::CALIB_USE_INTRINSIC_GUESS , REF: fisheye::CALIB_FIX_INTRINSIC are specified,
 *     some or all of the matrix components must be initialized.
 * @param D1 Input/output vector of distortion coefficients `$$\distcoeffsfisheye$$` of 4 elements.
 * @param K2 Input/output second camera intrinsic matrix. The parameter is similar to K1 .
 * @param D2 Input/output lens distortion coefficients for the second camera. The parameter is
 *     similar to D1 .
 * @param imageSize Size of the image used only to initialize camera intrinsic matrix.
 * @param R Output rotation matrix between the 1st and the 2nd camera coordinate systems.
 * @param T Output translation vector between the coordinate systems of the cameras.
 * @param flags Different flags that may be zero or a combination of the following values:
 *     -    REF: fisheye::CALIB_FIX_INTRINSIC  Fix K1, K2? and D1, D2? so that only R, T matrices
 *     are estimated.
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  K1, K2 contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center (imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -   REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay
 *     zero.
 */
+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 K1:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T flags:(int)flags NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:K1:D1:K2:D2:imageSize:R:T:flags:));

/**
 * Performs stereo calibration
 *
 * @param objectPoints Vector of vectors of the calibration pattern points.
 * @param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the first camera.
 * @param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
 *     observed by the second camera.
 * @param K1 Input/output first camera intrinsic matrix:
 *     `$$\newcommand{\vecthreethree}[9]{ \begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \end{bmatrix} } \vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}$$` , `$$j = 0,\, 1$$` . If
 *     any of REF: fisheye::CALIB_USE_INTRINSIC_GUESS , REF: fisheye::CALIB_FIX_INTRINSIC are specified,
 *     some or all of the matrix components must be initialized.
 * @param D1 Input/output vector of distortion coefficients `$$\distcoeffsfisheye$$` of 4 elements.
 * @param K2 Input/output second camera intrinsic matrix. The parameter is similar to K1 .
 * @param D2 Input/output lens distortion coefficients for the second camera. The parameter is
 *     similar to D1 .
 * @param imageSize Size of the image used only to initialize camera intrinsic matrix.
 * @param R Output rotation matrix between the 1st and the 2nd camera coordinate systems.
 * @param T Output translation vector between the coordinate systems of the cameras.
 *     -    REF: fisheye::CALIB_FIX_INTRINSIC  Fix K1, K2? and D1, D2? so that only R, T matrices
 *     are estimated.
 *     -    REF: fisheye::CALIB_USE_INTRINSIC_GUESS  K1, K2 contains valid initial values of
 *     fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
 *     center (imageSize is used), and focal distances are computed in a least-squares fashion.
 *     -    REF: fisheye::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
 *     of intrinsic optimization.
 *     -    REF: fisheye::CALIB_CHECK_COND  The functions will check validity of condition number.
 *     -    REF: fisheye::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
 *     -   REF: fisheye::CALIB_FIX_K1,..., REF: fisheye::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay
 *     zero.
 */
+ (double)stereoCalibrate:(NSArray<Mat*>*)objectPoints imagePoints1:(NSArray<Mat*>*)imagePoints1 imagePoints2:(NSArray<Mat*>*)imagePoints2 K1:(Mat*)K1 D1:(Mat*)D1 K2:(Mat*)K2 D2:(Mat*)D2 imageSize:(Size2i*)imageSize R:(Mat*)R T:(Mat*)T NS_SWIFT_NAME(stereoCalibrate(objectPoints:imagePoints1:imagePoints2:K1:D1:K2:D2:imageSize:R:T:));



@end

NS_ASSUME_NONNULL_END