Calib3d

@property (class, readonly) int CV_ITERATIVE

class var CV_ITERATIVE: Int32 { get }

@property (class, readonly) int CV_EPNP

class var CV_EPNP: Int32 { get }

@property (class, readonly) int CV_P3P

class var CV_P3P: Int32 { get }

@property (class, readonly) int CV_DLS

class var CV_DLS: Int32 { get }

@property (class, readonly) int CvLevMarq_DONE

class var CvLevMarq_DONE: Int32 { get }

@property (class, readonly) int CvLevMarq_STARTED

class var CvLevMarq_STARTED: Int32 { get }

@property (class, readonly) int CvLevMarq_CALC_J

class var CvLevMarq_CALC_J: Int32 { get }

@property (class, readonly) int CvLevMarq_CHECK_ERR

class var CvLevMarq_CHECK_ERR: Int32 { get }

@property (class, readonly) int LMEDS

class var LMEDS: Int32 { get }

@property (class, readonly) int RANSAC

class var RANSAC: Int32 { get }

@property (class, readonly) int RHO

class var RHO: Int32 { get }

@property (class, readonly) int CALIB_CB_ADAPTIVE_THRESH

class var CALIB_CB_ADAPTIVE_THRESH: Int32 { get }

@property (class, readonly) int CALIB_CB_NORMALIZE_IMAGE

class var CALIB_CB_NORMALIZE_IMAGE: Int32 { get }

@property (class, readonly) int CALIB_CB_FILTER_QUADS

class var CALIB_CB_FILTER_QUADS: Int32 { get }

@property (class, readonly) int CALIB_CB_FAST_CHECK

class var CALIB_CB_FAST_CHECK: Int32 { get }

@property (class, readonly) int CALIB_CB_EXHAUSTIVE

class var CALIB_CB_EXHAUSTIVE: Int32 { get }

@property (class, readonly) int CALIB_CB_ACCURACY

class var CALIB_CB_ACCURACY: Int32 { get }

@property (class, readonly) int CALIB_CB_LARGER

class var CALIB_CB_LARGER: Int32 { get }

@property (class, readonly) int CALIB_CB_MARKER

class var CALIB_CB_MARKER: Int32 { get }

@property (class, readonly) int CALIB_CB_SYMMETRIC_GRID

class var CALIB_CB_SYMMETRIC_GRID: Int32 { get }

@property (class, readonly) int CALIB_CB_ASYMMETRIC_GRID

class var CALIB_CB_ASYMMETRIC_GRID: Int32 { get }

@property (class, readonly) int CALIB_CB_CLUSTERING

class var CALIB_CB_CLUSTERING: Int32 { get }

@property (class, readonly) int CALIB_NINTRINSIC

class var CALIB_NINTRINSIC: Int32 { get }

@property (class, readonly) int CALIB_USE_INTRINSIC_GUESS

class var CALIB_USE_INTRINSIC_GUESS: Int32 { get }

@property (class, readonly) int CALIB_FIX_ASPECT_RATIO

class var CALIB_FIX_ASPECT_RATIO: Int32 { get }

@property (class, readonly) int CALIB_FIX_PRINCIPAL_POINT

class var CALIB_FIX_PRINCIPAL_POINT: Int32 { get }

@property (class, readonly) int CALIB_ZERO_TANGENT_DIST

class var CALIB_ZERO_TANGENT_DIST: Int32 { get }

@property (class, readonly) int CALIB_FIX_FOCAL_LENGTH

class var CALIB_FIX_FOCAL_LENGTH: Int32 { get }

@property (class, readonly) int CALIB_FIX_K1

class var CALIB_FIX_K1: Int32 { get }

@property (class, readonly) int CALIB_FIX_K2

class var CALIB_FIX_K2: Int32 { get }

@property (class, readonly) int CALIB_FIX_K3

class var CALIB_FIX_K3: Int32 { get }

@property (class, readonly) int CALIB_FIX_K4

class var CALIB_FIX_K4: Int32 { get }

@property (class, readonly) int CALIB_FIX_K5

class var CALIB_FIX_K5: Int32 { get }

@property (class, readonly) int CALIB_FIX_K6

class var CALIB_FIX_K6: Int32 { get }

@property (class, readonly) int CALIB_RATIONAL_MODEL

class var CALIB_RATIONAL_MODEL: Int32 { get }

@property (class, readonly) int CALIB_THIN_PRISM_MODEL

class var CALIB_THIN_PRISM_MODEL: Int32 { get }

@property (class, readonly) int CALIB_FIX_S1_S2_S3_S4

class var CALIB_FIX_S1_S2_S3_S4: Int32 { get }

@property (class, readonly) int CALIB_TILTED_MODEL

class var CALIB_TILTED_MODEL: Int32 { get }

@property (class, readonly) int CALIB_FIX_TAUX_TAUY

class var CALIB_FIX_TAUX_TAUY: Int32 { get }

@property (class, readonly) int CALIB_USE_QR

class var CALIB_USE_QR: Int32 { get }

@property (class, readonly) int CALIB_FIX_TANGENT_DIST

class var CALIB_FIX_TANGENT_DIST: Int32 { get }

@property (class, readonly) int CALIB_FIX_INTRINSIC

class var CALIB_FIX_INTRINSIC: Int32 { get }

@property (class, readonly) int CALIB_SAME_FOCAL_LENGTH

class var CALIB_SAME_FOCAL_LENGTH: Int32 { get }

@property (class, readonly) int CALIB_ZERO_DISPARITY

class var CALIB_ZERO_DISPARITY: Int32 { get }

@property (class, readonly) int CALIB_USE_LU

class var CALIB_USE_LU: Int32 { get }

@property (class, readonly) int CALIB_USE_EXTRINSIC_GUESS

class var CALIB_USE_EXTRINSIC_GUESS: Int32 { get }

@property (class, readonly) int FM_7POINT

class var FM_7POINT: Int32 { get }

@property (class, readonly) int FM_8POINT

class var FM_8POINT: Int32 { get }

@property (class, readonly) int FM_LMEDS

class var FM_LMEDS: Int32 { get }

@property (class, readonly) int FM_RANSAC

class var FM_RANSAC: Int32 { get }

@property (class, readonly) int CALIB_RECOMPUTE_EXTRINSIC

class var CALIB_RECOMPUTE_EXTRINSIC: Int32 { get }

@property (class, readonly) int CALIB_CHECK_COND

class var CALIB_CHECK_COND: Int32 { get }

@property (class, readonly) int CALIB_FIX_SKEW

class var CALIB_FIX_SKEW: Int32 { get }

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers
                           method:(int)method
            ransacReprojThreshold:(double)ransacReprojThreshold
                         maxIters:(size_t)maxIters
                       confidence:(double)confidence
                      refineIters:(size_t)refineIters;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int, confidence: Double, refineIters: Int) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers
                           method:(int)method
            ransacReprojThreshold:(double)ransacReprojThreshold
                         maxIters:(size_t)maxIters
                       confidence:(double)confidence;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int, confidence: Double) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers
                           method:(int)method
            ransacReprojThreshold:(double)ransacReprojThreshold
                         maxIters:(size_t)maxIters;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers
                           method:(int)method
            ransacReprojThreshold:(double)ransacReprojThreshold;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers
                           method:(int)method;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat, method: Int32) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from
                               to:(nonnull Mat *)to
                          inliers:(nonnull Mat *)inliers;

class func estimateAffine2D(from: Mat, to: Mat, inliers: Mat) -> Mat

Computes an optimal affine transformation between two 2D point sets.

It computes

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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.

+ (nonnull Mat *)estimateAffine2D:(nonnull Mat *)from to:(nonnull Mat *)to;

class func estimateAffine2D(from: Mat, to: Mat) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers
                                  method:(int)method
                   ransacReprojThreshold:(double)ransacReprojThreshold
                                maxIters:(size_t)maxIters
                              confidence:(double)confidence
                             refineIters:(size_t)refineIters;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int, confidence: Double, refineIters: Int) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers
                                  method:(int)method
                   ransacReprojThreshold:(double)ransacReprojThreshold
                                maxIters:(size_t)maxIters
                              confidence:(double)confidence;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int, confidence: Double) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers
                                  method:(int)method
                   ransacReprojThreshold:(double)ransacReprojThreshold
                                maxIters:(size_t)maxIters;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double, maxIters: Int) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method
• cv::LMEDS - Least-Median robust method RANSAC is the default method.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers
                                  method:(int)method
                   ransacReprojThreshold:(double)ransacReprojThreshold;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat, method: Int32, ransacReprojThreshold: Double) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers
                                  method:(int)method;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat, method: Int32) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to
                                 inliers:(nonnull Mat *)inliers;

class func estimateAffinePartial2D(from: Mat, to: Mat, inliers: Mat) -> Mat

Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

• cv::RANSAC - RANSAC-based robust method

• cv::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.

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:

Where is the rotation angle, the scaling factor and are translations in 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.

+ (nonnull Mat *)estimateAffinePartial2D:(nonnull Mat *)from
                                      to:(nonnull Mat *)to;

class func estimateAffinePartial2D(from: Mat, to: Mat) -> Mat

Calculates an essential matrix from the corresponding points in two images.

• RANSAC for the RANSAC algorithm.
• LMEDS for the LMedS algorithm.

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:

where

is an essential matrix, and 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.

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                     cameraMatrix:(nonnull Mat *)cameraMatrix
                           method:(int)method
                             prob:(double)prob
                        threshold:(double)threshold
                             mask:(nonnull Mat *)mask;

class func findEssentialMat(points1: Mat, points2: Mat, cameraMatrix: Mat, method: Int32, prob: Double, threshold: Double, mask: Mat) -> Mat

Calculates an essential matrix from the corresponding points in two images.

• RANSAC for the RANSAC algorithm.
• LMEDS for the LMedS algorithm.

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:

where

is an essential matrix, and 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.

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                     cameraMatrix:(nonnull Mat *)cameraMatrix
                           method:(int)method
                             prob:(double)prob
                        threshold:(double)threshold;

class func findEssentialMat(points1: Mat, points2: Mat, cameraMatrix: Mat, method: Int32, prob: Double, threshold: Double) -> Mat

Calculates an essential matrix from the corresponding points in two images.

• RANSAC for the RANSAC algorithm.
• LMEDS for the LMedS algorithm.

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:

where

is an essential matrix, and 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.

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                     cameraMatrix:(nonnull Mat *)cameraMatrix
                           method:(int)method
                             prob:(double)prob;

class func findEssentialMat(points1: Mat, points2: Mat, cameraMatrix: Mat, method: Int32, prob: Double) -> Mat

Calculates an essential matrix from the corresponding points in two images.

• RANSAC for the RANSAC algorithm.
• 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:

where

is an essential matrix, and 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.

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                     cameraMatrix:(nonnull Mat *)cameraMatrix
                           method:(int)method;

class func findEssentialMat(points1: Mat, points2: Mat, cameraMatrix: Mat, method: Int32) -> Mat

Calculates an essential matrix from the corresponding points in two images.

• RANSAC for the RANSAC algorithm.
• 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:

where

is an essential matrix, and 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.

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                     cameraMatrix:(nonnull Mat *)cameraMatrix;

class func findEssentialMat(points1: Mat, points2: Mat, cameraMatrix: Mat) -> Mat

• RANSAC for the RANSAC algorithm.
• LMEDS for the LMedS algorithm.

This function differs from the one above that it computes camera matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal
                               pp:(nonnull Point2d *)pp
                           method:(int)method
                             prob:(double)prob
                        threshold:(double)threshold
                             mask:(nonnull Mat *)mask;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double, pp: Point2d, method: Int32, prob: Double, threshold: Double, mask: Mat) -> Mat

• RANSAC for the RANSAC algorithm.
• LMEDS for the LMedS algorithm.

This function differs from the one above that it computes camera matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal
                               pp:(nonnull Point2d *)pp
                           method:(int)method
                             prob:(double)prob
                        threshold:(double)threshold;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double, pp: Point2d, method: Int32, prob: Double, threshold: Double) -> Mat

• RANSAC for the RANSAC algorithm.
• 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.

This function differs from the one above that it computes camera matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal
                               pp:(nonnull Point2d *)pp
                           method:(int)method
                             prob:(double)prob;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double, pp: Point2d, method: Int32, prob: Double) -> Mat

• RANSAC for the RANSAC algorithm.
• 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 matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal
                               pp:(nonnull Point2d *)pp
                           method:(int)method;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double, pp: Point2d, method: Int32) -> Mat

• RANSAC for the RANSAC algorithm.
• 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 matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal
                               pp:(nonnull Point2d *)pp;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double, pp: Point2d) -> Mat

• RANSAC for the RANSAC algorithm.
• 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 matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2
                            focal:(double)focal;

class func findEssentialMat(points1: Mat, points2: Mat, focal: Double) -> Mat

• RANSAC for the RANSAC algorithm.
• 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 matrix from focal length and principal point:

+ (nonnull Mat *)findEssentialMat:(nonnull Mat *)points1
                          points2:(nonnull Mat *)points2;

class func findEssentialMat(points1: Mat, points2: Mat) -> Mat

Calculates a fundamental matrix from the corresponding points in two images.

• CV_FM_7POINT for a 7-point algorithm.
  N = 7
• CV_FM_8POINT for an 8-point algorithm.
  N \ge 8
• CV_FM_RANSAC for the RANSAC algorithm.
  N \ge 8
• CV_FM_LMEDS for the LMedS algorithm.
  N \ge 8

The epipolar geometry is described by the following equation:

where

is a fundamental matrix, and 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 (

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);

+ (nonnull Mat *)findFundamentalMat:(nonnull Mat *)points1
                            points2:(nonnull Mat *)points2
                             method:(int)method
              ransacReprojThreshold:(double)ransacReprojThreshold
                         confidence:(double)confidence
                           maxIters:(int)maxIters
                               mask:(nonnull Mat *)mask;

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32, ransacReprojThreshold: Double, confidence: Double, maxIters: Int32, mask: Mat) -> Mat

Calculates a fundamental matrix from the corresponding points in two images.

• CV_FM_7POINT for a 7-point algorithm.
  N = 7
• CV_FM_8POINT for an 8-point algorithm.
  N \ge 8
• CV_FM_RANSAC for the RANSAC algorithm.
  N \ge 8
• CV_FM_LMEDS for the LMedS algorithm.
  N \ge 8

The epipolar geometry is described by the following equation:

where

is a fundamental matrix, and 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 (

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);

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

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32, ransacReprojThreshold: Double, confidence: Double, maxIters: Int32) -> 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:));

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32, ransacReprojThreshold: Double, confidence: Double, mask: Mat) -> Mat

+ (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:));

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32, ransacReprojThreshold: Double, confidence: Double) -> Mat

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

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32, ransacReprojThreshold: Double) -> Mat

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

class func findFundamentalMat(points1: Mat, points2: Mat, method: Int32) -> Mat

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

class func findFundamentalMat(points1: Mat, points2: Mat) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• RHO - PROSAC-based robust method

The function finds and returns the perspective transformation

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints
                         method:(int)method
          ransacReprojThreshold:(double)ransacReprojThreshold
                           mask:(nonnull Mat *)mask
                       maxIters:(int)maxIters
                     confidence:(double)confidence;

class func findHomography(srcPoints: Mat, dstPoints: Mat, method: Int32, ransacReprojThreshold: Double, mask: Mat, maxIters: Int32, confidence: Double) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• RHO - PROSAC-based robust method

The function finds and returns the perspective transformation

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints
                         method:(int)method
          ransacReprojThreshold:(double)ransacReprojThreshold
                           mask:(nonnull Mat *)mask
                       maxIters:(int)maxIters;

class func findHomography(srcPoints: Mat, dstPoints: Mat, method: Int32, ransacReprojThreshold: Double, mask: Mat, maxIters: Int32) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• RHO - PROSAC-based robust method

The function finds and returns the perspective transformation

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints
                         method:(int)method
          ransacReprojThreshold:(double)ransacReprojThreshold
                           mask:(nonnull Mat *)mask;

class func findHomography(srcPoints: Mat, dstPoints: Mat, method: Int32, ransacReprojThreshold: Double, mask: Mat) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• RHO - PROSAC-based robust method

The function finds and returns the perspective transformation

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints
                         method:(int)method
          ransacReprojThreshold:(double)ransacReprojThreshold;

class func findHomography(srcPoints: Mat, dstPoints: Mat, method: Int32, ransacReprojThreshold: Double) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• 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

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints
                         method:(int)method;

class func findHomography(srcPoints: Mat, dstPoints: Mat, method: Int32) -> Mat

Finds a perspective transformation between two planes.

• 0 - a regular method using all the points, i.e., the least squares method
• RANSAC - RANSAC-based robust method
• LMEDS - Least-Median robust method
• 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

between the source and the destination planes:

so that the back-projection error

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 (

, ) 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

. Note that whenever an matrix cannot be estimated, an empty one will be returned.

@sa getAffineTransform, estimateAffine2D, estimateAffinePartial2D, getPerspectiveTransform, warpPerspective, perspectiveTransform

+ (nonnull Mat *)findHomography:(nonnull Mat *)srcPoints
                      dstPoints:(nonnull Mat *)dstPoints;

class func findHomography(srcPoints: Mat, dstPoints: Mat) -> Mat