OpenCvSharp

OpenCV Functions of C++ I/F (cv::xxx)

The ratio of a circle's circumference to its diameter

引数がnullの時はIntPtr.Zeroに変換する

converts rotation vector to rotation matrix or vice versa using Rodrigues transformation

Input rotation vector (3x1 or 1x3) or rotation matrix (3x3). Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively. 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.

converts rotation vector to rotation matrix using Rodrigues transformation

Input rotation vector (3x1). Output rotation matrix (3x3). Optional output Jacobian matrix, 3x9, which is a matrix of partial derivatives of the output array components with respect to the input array components.

converts rotation matrix to rotation vector using Rodrigues transformation

Input rotation matrix (3x3). Output rotation vector (3x1). Optional output Jacobian matrix, 3x9, which is a matrix of partial derivatives of the output array components with respect to the input array components.

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

Coordinates of the points in the original plane, a matrix of the type CV_32FC2 Coordinates of the points in the target plane, a matrix of the type CV_32FC2 Method used to computed a homography matrix. Maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only) Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored. The maximum number of RANSAC iterations. Confidence level, between 0 and 1.

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

Coordinates of the points in the original plane Coordinates of the points in the target plane Method used to computed a homography matrix. Maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only) Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored. The maximum number of RANSAC iterations. Confidence level, between 0 and 1.

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

Coordinates of the points in the original plane, a matrix of the type CV_32FC2 Coordinates of the points in the target plane, a matrix of the type CV_32FC2 Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored.

Computes RQ decomposition of 3x3 matrix

3x3 input matrix. Output 3x3 upper-triangular matrix. Output 3x3 orthogonal matrix. Optional output 3x3 rotation matrix around x-axis. Optional output 3x3 rotation matrix around y-axis. Optional output 3x3 rotation matrix around z-axis.

Computes RQ decomposition of 3x3 matrix

3x3 input matrix. Output 3x3 upper-triangular matrix. Output 3x3 orthogonal matrix.

Computes RQ decomposition of 3x3 matrix

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

3x4 input projection matrix P. Output 3x3 camera matrix K. Output 3x3 external rotation matrix R. Output 4x1 translation vector T. Optional 3x3 rotation matrix around x-axis. Optional 3x3 rotation matrix around y-axis. Optional 3x3 rotation matrix around z-axis. ptional three-element vector containing three Euler angles of rotation in degrees.

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

3x4 input projection matrix P. Output 3x3 camera matrix K. Output 3x3 external rotation matrix R. Output 4x1 translation vector T.

computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients

First multiplied matrix. Second multiplied matrix. First output derivative matrix d(A*B)/dA of size A.rows*B.cols X A.rows*A.cols . Second output derivative matrix d(A*B)/dB of size A.rows*B.cols X B.rows*B.cols .

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

First rotation vector. First translation vector. Second rotation vector. Second translation vector. Output rotation vector of the superposition. Output translation vector of the superposition. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively. Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

First rotation vector. First translation vector. Second rotation vector. Second translation vector. Output rotation vector of the superposition. Output translation vector of the superposition.

projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters

Array of object points, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points in the view. Rotation vector (3x1). Translation vector (3x1). Camera matrix (3x3) Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the vector is null, the zero distortion coefficients are assumed. Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel 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. Optional “fixed aspect ratio” parameter. If the parameter is not 0, the function assumes that the aspect ratio (fx/fy) is fixed and correspondingly adjusts the jacobian matrix.

projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters

Finds an object pose from 3D-2D point correspondences.

Array of object points in the object coordinate space, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points. vector<Point3f> can be also passed here. Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. vector<Point2f> can be also passed here. Input camera matrix Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the vector is null, the zero distortion coefficients are assumed. Output rotation vector that, together with tvec , brings points from the model coordinate system to the camera coordinate system. Output translation vector. If true, the function uses the provided rvec and tvec values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them. Method for solving a PnP problem:

Finds an object pose from 3D-2D point correspondences.

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.

Array of object points in the object coordinate space, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points. List<Point3f> can be also passed here. Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. List<Point2f> can be also passed here. Input 3x3 camera matrix Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the vector is null, the zero distortion coefficients are assumed. Output rotation vector that, together with tvec , brings points from the model coordinate system to the camera coordinate system. Output translation vector. If true, the function uses the provided rvec and tvec values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them. Number of iterations. 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 probability that the algorithm produces a useful result. Output vector that contains indices of inliers in objectPoints and imagePoints . Method for solving a PnP problem

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.

initializes camera matrix from a few 3D points and the corresponding projections.

Vector of vectors (vector<vector<Point3d>>) of the calibration pattern points in the calibration pattern coordinate space. In the old interface all the per-view vectors are concatenated. Vector of vectors (vector<vector<Point2d>>) of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated. Image size in pixels used to initialize the principal point. If it is zero or negative, both f_x and f_y are estimated independently. Otherwise, f_x = f_y * aspectRatio .

initializes camera matrix from a few 3D points and the corresponding projections.

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. Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated. Image size in pixels used to initialize the principal point. If it is zero or negative, both f_x and f_y are estimated independently. Otherwise, f_x = f_y * aspectRatio .

Finds the positions of internal corners of the chessboard.

Source chessboard view. It must be an 8-bit grayscale or color image. Number of inner corners per a chessboard row and column ( patternSize = Size(points_per_row,points_per_colum) = Size(columns, rows) ). Output array of detected corners. Various operation flags that can be zero or a combination of the ChessboardFlag values The function returns true 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 false.

Finds the positions of internal corners of the chessboard.

Checks whether the image contains chessboard of the specific size or not.

Finds the positions of internal corners of the chessboard using a sector based approach.

image Source chessboard view. It must be an 8-bit grayscale or color image. Number of inner corners per a chessboard row and column (patternSize = Size(points_per_row, points_per_column) = Size(columns, rows) ). Output array of detected corners. flags Various operation flags that can be zero or a combination of the ChessboardFlags values.

Finds the positions of internal corners of the chessboard using a sector based approach.

finds subpixel-accurate positions of the chessboard corners

Renders the detected chessboard corners.

Destination image. It must be an 8-bit color image. Number of inner corners per a chessboard row and column (patternSize = cv::Size(points_per_row,points_per_column)). Array of detected corners, the output of findChessboardCorners. Parameter indicating whether the complete board was found or not. The return value of findChessboardCorners() should be passed here.

Renders the detected chessboard corners.

Draw axes of the world/object coordinate system from pose estimation.

Input/output image. It must have 1 or 3 channels. The number of channels is not altered. Input 3x3 floating-point matrix of camera intrinsic parameters. Input vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of 4, 5, 8, 12 or 14 elements.If the vector is empty, the zero distortion coefficients are assumed. Rotation vector (see @ref Rodrigues ) that, together with tvec , brings points from the model coordinate system to the camera coordinate system. Translation vector. Length of the painted axes in the same unit than tvec (usually in meters). 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.

Finds centers in the grid of circles.

grid view of input circles; it must be an 8-bit grayscale or color image. number of circles per row and column ( patternSize = Size(points_per_row, points_per_colum) ). output array of detected centers. various operation flags that can be one of the FindCirclesGridFlag values feature detector that finds blobs like dark circles on light background.

Finds centers in the grid of circles.

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. The outer vector contains as many elements as the number of the 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. The points are 3D, but since they are in a pattern coordinate system, then, if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0. In the old interface all the vectors of object points from different views are concatenated together. In the new interface it is a vector of vectors of the projections of calibration pattern points. imagePoints.Count() and objectPoints.Count() and imagePoints[i].Count() must be equal to objectPoints[i].Count() for each i. Size of the image used only to initialize the intrinsic camera matrix. Output 3x3 floating-point camera matrix. If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATIO are specified, some or all of fx, fy, cx, cy must be initialized before calling the function. Output vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. 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) Output vector of translation vectors estimated for each pattern view. Different flags that may be zero or a combination of the CalibrationFlag values Termination criteria for the iterative optimization algorithm.

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

Input camera matrix that can be estimated by calibrateCamera() or stereoCalibrate() . Input image size in pixels. Physical width of the sensor. Physical height of the sensor. Output field of view in degrees along the horizontal sensor axis. Output field of view in degrees along the vertical sensor axis. Focal length of the lens in mm. Principal point in pixels. fy / fx

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

finds intrinsic and extrinsic parameters of a stereo camera

Vector of vectors of the calibration pattern points. Vector of vectors of the projections of the calibration pattern points, observed by the first camera. Vector of vectors of the projections of the calibration pattern points, observed by the second camera. Input/output first camera matrix Input/output vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. The output vector length depends on the flags. Input/output second camera matrix. The parameter is similar to cameraMatrix1 . Input/output lens distortion coefficients for the second camera. The parameter is similar to distCoeffs1 . Size of the image used only to initialize intrinsic camera matrix. Output rotation matrix between the 1st and the 2nd camera coordinate systems. Output translation vector between the coordinate systems of the cameras. Output essential matrix. Output fundamental matrix. Termination criteria for the iterative optimization algorithm. Different flags that may be zero or a combination of the CalibrationFlag values

finds intrinsic and extrinsic parameters of a stereo camera

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

First camera matrix. First camera distortion parameters. Second camera matrix. Second camera distortion parameters. Size of the image used for stereo calibration. Rotation matrix between the coordinate systems of the first and the second cameras. Translation vector between coordinate systems of the cameras. Output 3x3 rectification transform (rotation matrix) for the first camera. Output 3x3 rectification transform (rotation matrix) for the second camera. Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera. Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera. Output 4x4 disparity-to-depth mapping matrix (see reprojectImageTo3D() ). Operation flags that may be zero or CV_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. 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). Obviously, any intermediate value yields an intermediate result between those two extreme cases. New image resolution after rectification. The same size should be passed to initUndistortRectifyMap(). 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.

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)

Array of feature points in the first image. The corresponding points in the second image. The same formats as in findFundamentalMat() are supported. Input fundamental matrix. It can be computed from the same set of point pairs using findFundamentalMat() . Size of the image. Output rectification homography matrix for the first image. Output rectification homography matrix for the second image. 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 |points2[i]^T * F * points1[i]| > threshold ) are rejected prior to computing the homographies. Otherwise, all the points are considered inliers.

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)

computes the rectification transformations for 3-head camera, where all the heads are on the same line.

Returns the new camera matrix based on the free scaling parameter.

Input camera matrix. Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the array is null, the zero distortion coefficients are assumed. Original image size. 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). Image size after rectification. By default,it is set to imageSize . Optional output rectangle that outlines all-good-pixels region in the undistorted image. See roi1, roi2 description in stereoRectify() . Optional flag that indicates whether in the new camera 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. optimal new camera matrix

Returns the new camera matrix based on the free scaling parameter.

Computes Hand-Eye calibration. 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 method: - N.Andreff, R.Horaud, B.Espiau On-line Hand-Eye Calibration \cite Andreff99 - K.Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98

Rotation part extracted from the homogeneous matrix that transforms a pointexpressed in the gripper frame to the robot base frame that contains the rotation matrices for all the transformationsfrom gripper frame to robot base frame. Translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame. This is a vector(`vector<Mat>`) that contains the translation vectors for all the transformations from gripper frame to robot base frame. Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame. This is a vector(`vector<Mat>`) that contains the rotation matrices for all the transformations from calibration target frame to camera frame. Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame. This is a vector(`vector<Mat>`) that contains the translation vectors for all the transformations from calibration target frame to camera frame. Estimated rotation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame. Estimated translation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame. One of the implemented Hand-Eye calibration method

Computes Robot-World/Hand-Eye calibration. 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

[in] R_world2cam Rotation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame. This is a vector of Mat that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,for all the transformations from world frame to the camera frame. [in] Translation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame. This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations from world frame to the camera frame. [in] Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame. 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. [in] Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame. This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations from robot base frame to the gripper frame. [out] 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. [out] 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. [out] R_gripper2cam Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the camera frame. [out] Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a pointexpressed in the gripper frame to the camera frame. One of the implemented Robot-World/Hand-Eye calibration method

omputes Robot-World/Hand-Eye calibration. 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

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

Input vector of N-dimensional points. Output vector of N+1-dimensional points.

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

Input vector of N-dimensional points. Output vector of N+1-dimensional points.

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

Input vector of N-dimensional points. Output vector of N+1-dimensional points.

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

Input vector of N-dimensional points. Output vector of N-1-dimensional points.

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

Input vector of N-dimensional points. Output vector of N-1-dimensional points.

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

Input vector of N-dimensional points. Output vector of N-1-dimensional points.

Converts points to/from homogeneous coordinates.

Input array or vector of 2D, 3D, or 4D points. Output vector of 2D, 3D, or 4D points.

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

Array of N points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image points of the same size and format as points1 . Method for computing a fundamental matrix. 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. Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct. 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. For other methods, it is set to all 1’s. fundamental matrix

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

For points in an image of a stereo pair, computes the corresponding epilines in the other image.

Input points. N \times 1 or 1 x N matrix of type CV_32FC2 or CV_64FC2. Index of the image (1 or 2) that contains the points . Fundamental matrix that can be estimated using findFundamentalMat() or stereoRectify() . 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 points in an image of a stereo pair, computes the corresponding epilines in the other image.

Reconstructs points by triangulation.

3x4 projection matrix of the first camera. 3x4 projection matrix of the second camera. 2xN array of feature points in the first image. In case of c++ version it can be also a vector of feature points or two-channel matrix of size 1xN or Nx1. 2xN array of corresponding points in the second image. In case of c++ version it can be also a vector of feature points or two-channel matrix of size 1xN or Nx1. 4xN array of reconstructed points in homogeneous coordinates.

Reconstructs points by triangulation.

Refines coordinates of corresponding points.

3x3 fundamental matrix. 1xN array containing the first set of points. 1xN array containing the second set of points. The optimized points1. The optimized points2.

Refines coordinates of corresponding points.

3x3 fundamental matrix. 1xN array containing the first set of points. 1xN array containing the second set of points. The optimized points1. The optimized points2.

Recover relative camera rotation and translation from an estimated essential matrix and the corresponding points in two images, using cheirality check. Returns the number of inliers which pass the check.

The input essential matrix. Array of N 2D points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image points of the same size and format as points1. Camera matrix K=⎡⎣⎢fx000fy0cxcy1⎤⎦⎥ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix. Recovered relative rotation. Recovered relative translation. 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 decomposeEssentialMat and then verifies possible pose hypotheses by doing cheirality check. The cheirality check basically means that the triangulated 3D points should have positive depth.

The input essential matrix. Array of N 2D points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image points of the same size and format as points1. Recovered relative rotation. Recovered relative translation. 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. principal point of the camera. 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 decomposeEssentialMat and then verifies possible pose hypotheses by doing cheirality check. The cheirality check basically means that the triangulated 3D points should have positive depth.

The input essential matrix. Array of N 2D points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image points of the same size and format as points1. Camera matrix K=⎡⎣⎢fx000fy0cxcy1⎤⎦⎥ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix. Recovered relative rotation. Recovered relative translation. threshold distance which is used to filter out far away points (i.e. infinite points). 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 decomposeEssentialMat and then verifies possible pose hypotheses by doing cheirality check. The cheirality check basically means that the triangulated 3D points should have positive depth. 3d points which were reconstructed by triangulation.

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

Array of N (N >= 5) 2D points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image points of the same size and format as points1 . Camera matrix K=⎡⎣⎢fx000fy0cxcy1⎤⎦⎥ . Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix. Method for computing an essential matrix. RANSAC for the RANSAC algorithm. LMEDS for the LMedS algorithm. Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct. 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. 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. essential matrix

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

Array of N (N >= 5) 2D points from the first image. The point coordinates should be floating-point (single or double precision). Array of the second image por LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct. 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 ints of the same size and format as points1 . 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. principal point of the camera. Method for computing an essential matrix. RANSAC for the RANSAC algorithm. LMEDS for the LMedS algorithm. Parameter used for the RANSAC othe accuracy of the point localization, image resolution, and the image noise. 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. essential matrix

filters off speckles (small regions of incorrectly computed disparity)

The input 16-bit signed disparity image The disparity value used to paint-off the speckles The maximum speckle size to consider it a speckle. Larger blobs are not affected by the algorithm 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. The optional temporary buffer to avoid memory allocation within the function.

computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())

validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm

reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify

Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image. 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. 4 x 4 perspective transformation matrix that can be obtained with stereoRectify(). 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 StereoBM::operator() ) are transformed to 3D points with a very large Z value (currently set to 10000). he 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.

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

First input 3D point set. Second input 3D point set. Output 3D affine transformation matrix 3 x 4 . Output vector indicating which points are inliers. Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier. 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.

Calculates the Sampson Distance between two points.

first homogeneous 2d point second homogeneous 2d point F fundamental matrix The computed Sampson distance. https://github.com/opencv/opencv/blob/master/modules/calib3d/src/fundam.cpp#L1109

Calculates the Sampson Distance between two points.

first homogeneous 2d point second homogeneous 2d point F fundamental matrix The computed Sampson distance. https://github.com/opencv/opencv/blob/master/modules/calib3d/src/fundam.cpp#L1109

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

First input 2D point set containing (X,Y). Second input 2D point set containing (x,y). Output vector indicating which points are inliers (1-inlier, 0-outlier). Robust method used to compute transformation. Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier.Applies only to RANSAC. The maximum number of robust method iterations. 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. Maximum number of iterations of refining algorithm (Levenberg-Marquardt). Passing 0 will disable refining, so the output matrix will be output of robust method. Output 2D affine transformation matrix \f$2 \times 3\f$ or empty matrix if transformation could not be estimated.

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

First input 2D point set. Second input 2D point set. Output vector indicating which points are inliers. Robust method used to compute transformation. Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier.Applies only to RANSAC. The maximum number of robust method iterations. 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. Output 2D affine transformation (4 degrees of freedom) matrix 2x3 or empty matrix if transformation could not be estimated.

Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).

The input homography matrix between two images. The input intrinsic camera calibration matrix. Array of rotation matrices. Array of translation matrices. Array of plane normal matrices.

Filters homography decompositions based on additional information.

Vector of rotation matrices. Vector of plane normal matrices. Vector of (rectified) visible reference points before the homography is applied Vector of (rectified) visible reference points after the homography is applied Vector of int indices representing the viable solution set after filtering optional Mat/Vector of 8u type representing the mask for the inliers as given by the findHomography function

corrects lens distortion for the given camera matrix and distortion coefficients

Input (distorted) image. Output (corrected) image that has the same size and type as src . Input camera matrix Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the vector is null, the zero distortion coefficients are assumed. 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.

initializes maps for cv::remap() to correct lens distortion and optionally rectify the image

initializes maps for cv::remap() for wide-angle

returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)

Input camera matrix. Camera view image size in pixels. Location of the principal point in the new camera matrix. The parameter indicates whether this location should be at the image center or not. the camera matrix that is either an exact copy of the input cameraMatrix (when centerPrinicipalPoint=false), or the modified one (when centerPrincipalPoint=true).

Computes the ideal point coordinates from the observed point coordinates.

Observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or CV_64FC2). Output ideal point coordinates after undistortion and reverse perspective transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates. Camera matrix Input vector of distortion coefficients (k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]]) of 4, 5, or 8 elements. If the vector is null, the zero distortion coefficients are assumed. 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. New camera matrix (3x3) or new projection matrix (3x4). P1 or P2 computed by stereoRectify() can be passed here. If the matrix is empty, the identity new camera matrix is used.

Computes the ideal point coordinates from the observed point coordinates.

The methods in this class use a so-called fisheye camera model.

Projects points using fisheye model. The function computes 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.

Array of object points, 1xN/Nx1 3-channel (or vector<Point3f> ), where N is the number of points in the view. Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or vector<Point2f>. Camera matrix Input vector of distortion coefficients The skew coefficient. Optional output 2Nx15 jacobian matrix of derivatives of image points with respect to components of the focal lengths, coordinates of the principal point, distortion coefficients, rotation vector, translation vector, and the skew.In the old interface different components of the jacobian are returned via different output parameters.

Distorts 2D points using fisheye model.

Array of object points, 1xN/Nx1 2-channel (or vector<Point2f> ), where N is the number of points in the view. Output array of image points, 1xN/Nx1 2-channel, or vector<Point2f> . Camera matrix Input vector of distortion coefficients The skew coefficient.

Undistorts 2D points using fisheye model

Array of object points, 1xN/Nx1 2-channel (or vector<Point2f> ), where N is the number of points in the view. Output array of image points, 1xN/Nx1 2-channel, or vector>Point2f> . Camera matrix Input vector of distortion coefficients (k_1, k_2, k_3, k_4). Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel New camera matrix (3x3) or new projection matrix (3x4)

Computes undistortion and rectification maps for image transform by cv::remap(). If D is empty zero distortion is used, if R or P is empty identity matrixes are used.

Camera matrix Input vector of distortion coefficients (k_1, k_2, k_3, k_4). Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel New camera matrix (3x3) or new projection matrix (3x4) Undistorted image size. Type of the first output map that can be CV_32FC1 or CV_16SC2 . See convertMaps() for details. The first output map. The second output map.

Transforms an image to compensate for fisheye lens distortion.

image with fisheye lens distortion. Output image with compensated fisheye lens distortion. Camera matrix Input vector of distortion coefficients (k_1, k_2, k_3, k_4). Camera 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.

Estimates new camera matrix for undistortion or rectification.

Camera matrix Input vector of distortion coefficients (k_1, k_2, k_3, k_4). Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel New camera matrix (3x3) or new projection matrix (3x4) Sets the new focal length in range between the min focal length and the max focal length.Balance is in range of[0, 1]. Divisor for new focal length.

Performs camera calibaration

vector of vectors of calibration pattern points in the calibration pattern coordinate space. 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. Size of the image used only to initialize the intrinsic camera matrix. Output 3x3 floating-point camera matrix Output vector of distortion coefficients (k_1, k_2, k_3, k_4). 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). Output vector of translation vectors estimated for each pattern view. Different flags that may be zero or a combination of flag values Termination criteria for the iterative optimization algorithm.

Stereo rectification for fisheye camera model

Performs stereo calibration

Vector of vectors of the calibration pattern points. Vector of vectors of the projections of the calibration pattern points, observed by the first camera. Vector of vectors of the projections of the calibration pattern points, observed by the second camera. Input/output first camera matrix Input/output vector of distortion coefficients (k_1, k_2, k_3, k_4) of 4 elements. Input/output second camera matrix. The parameter is similar to K1 . Input/output lens distortion coefficients for the second camera. The parameter is similar to D1. Size of the image used only to initialize intrinsic camera matrix. Output rotation matrix between the 1st and the 2nd camera coordinate systems. Output translation vector between the coordinate systems of the cameras. Different flags that may be zero or a combination of the FishEyeCalibrationFlags values Termination criteria for the iterative optimization algorithm.

Computes the source location of an extrapolated pixel.

0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= len Length of the array along the corresponding axis. Border type, one of the #BorderTypes, except for #BORDER_TRANSPARENT and BORDER_ISOLATED. When borderType==BORDER_CONSTANT, the function always returns -1, regardless

Forms a border around the image

The source image The destination image; will have the same type as src and the size Size(src.cols+left+right, src.rows+top+bottom) Specify how much pixels in each direction from the source image rectangle one needs to extrapolate Specify how much pixels in each direction from the source image rectangle one needs to extrapolate Specify how much pixels in each direction from the source image rectangle one needs to extrapolate Specify how much pixels in each direction from the source image rectangle one needs to extrapolate The border type The border value if borderType == Constant

Computes the per-element sum of two arrays or an array and a scalar.

The first source array The second source array. It must have the same size and same type as src1 The destination array; it will have the same size and same type as src1 The optional operation mask, 8-bit single channel array; specifies elements of the destination array to be changed. [By default this is null]

Calculates per-element difference between two arrays or array and a scalar

Calculates the per-element scaled product of two arrays

The first source array The second source array of the same size and the same type as src1 The destination array; will have the same size and the same type as src1 The optional scale factor. [By default this is 1]

Performs per-element division of two arrays or a scalar by an array.

The first source array The second source array; should have the same size and same type as src1 The destination array; will have the same size and same type as src2 Scale factor [By default this is 1]

Performs per-element division of two arrays or a scalar by an array.

Scale factor The first source array The destination array; will have the same size and same type as src2

adds scaled array to another one (dst = alpha*src1 + src2)

computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)

Scales, computes absolute values and converts the result to 8-bit.

The source array The destination array The optional scale factor. [By default this is 1] The optional delta added to the scaled values. [By default this is 0]

Converts an array to half precision floating number. This function converts FP32(single precision floating point) from/to FP16(half precision floating point). CV_16S format is used to represent FP16 data. There are two use modes(src -> dst) : CV_32F -> CV_16S and CV_16S -> CV_32F.The input array has to have type of CV_32F or CV_16S to represent the bit depth.If the input array is neither of them, the function will raise an error. The format of half precision floating point is defined in IEEE 754-2008.

input array. output array.

transforms array of numbers using a lookup table: dst(i)=lut(src(i))

Source array of 8-bit elements Look-up table of 256 elements. In the case of multi-channel source array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the source array Destination array; will have the same size and the same number of channels as src, and the same depth as lut

transforms array of numbers using a lookup table: dst(i)=lut(src(i))

computes sum of array elements

The source array; must have 1 to 4 channels

computes the number of nonzero array elements

Single-channel array number of non-zero elements in mtx

returns the list of locations of non-zero pixels

computes mean value of selected array elements

The source array; it should have 1 to 4 channels (so that the result can be stored in Scalar) The optional operation mask

computes mean value and standard deviation of all or selected array elements

The source array; it should have 1 to 4 channels (so that the results can be stored in Scalar's) The output parameter: computed mean value The output parameter: computed standard deviation The optional operation mask

computes mean value and standard deviation of all or selected array elements

Calculates absolute array norm, absolute difference norm, or relative difference norm.

The first source array Type of the norm The optional operation mask

computes norm of selected part of the difference between two arrays

The first source array The second source array of the same size and the same type as src1 Type of the norm The optional operation mask

Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. This function calculates the Peak Signal-to-Noise Ratio(PSNR) image quality metric in decibels(dB), between two input arrays src1 and src2.The arrays must have the same type.

first input array. second input array of the same size as src1. the maximum pixel value (255 by default)

naive nearest neighbor finder

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

The source array The destination array; will have the same size as src The norm value to normalize to or the lower range boundary in the case of range normalization The upper range boundary in the case of range normalization; not used for norm normalization The normalization type When the parameter is negative, the destination array will have the same type as src, otherwise it will have the same number of channels as src and the depth =CV_MAT_DEPTH(rtype) The optional operation mask

Finds indices of max elements along provided axis

Input single-channel array Output array of type CV_32SC1 with the same dimensionality as src, except for axis being reduced - it should be set to 1. Axis to reduce along Whether to get the index of first or last occurrence of max

Finds indices of min elements along provided axis

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array Pointer to returned minimum value Pointer to returned maximum value

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array Pointer to returned minimum location Pointer to returned maximum location

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array Pointer to returned minimum value Pointer to returned maximum value Pointer to returned minimum location Pointer to returned maximum location The optional mask used to select a sub-array

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array Pointer to returned minimum value Pointer to returned maximum value

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array

finds global minimum and maximum array elements and returns their values and their locations

The source single-channel array Pointer to returned minimum value Pointer to returned maximum value

transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows

The source 2D matrix The destination vector. Its size and type is defined by dim and dtype parameters The dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row and 1 means that the matrix is reduced to a single column When it is negative, the destination vector will have the same type as the source matrix, otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), mtx.channels())

makes multi-channel array out of several single-channel arrays

Copies each plane of a multi-channel array to a dedicated array

The source multi-channel array The destination array or vector of arrays; The number of arrays must match mtx.channels() . The arrays themselves will be reallocated if needed

Copies each plane of a multi-channel array to a dedicated array

The source multi-channel array The number of arrays must match mtx.channels() . The arrays themselves will be reallocated if needed

copies selected channels from the input arrays to the selected channels of the output arrays

extracts a single channel from src (coi is 0-based index)

inserts a single channel to dst (coi is 0-based index)

reverses the order of the rows, columns or both in a matrix

The source array The destination array; will have the same size and same type as src Specifies how to flip the array: 0 means flipping around the x-axis, positive (e.g., 1) means flipping around y-axis, and negative (e.g., -1) means flipping around both axes. See also the discussion below for the formulas.

Rotates a 2D array in multiples of 90 degrees.

input array. output array of the same type as src. The size is the same with ROTATE_180, and the rows and cols are switched for ROTATE_90_CLOCKWISE and ROTATE_90_COUNTERCLOCKWISE. an enum to specify how to rotate the array.

replicates the input matrix the specified number of times in the horizontal and/or vertical direction

The source array to replicate How many times the src is repeated along the vertical axis How many times the src is repeated along the horizontal axis The destination array; will have the same type as src

replicates the input matrix the specified number of times in the horizontal and/or vertical direction

The source array to replicate How many times the src is repeated along the vertical axis How many times the src is repeated along the horizontal axis

Applies horizontal concatenation to given matrices.

input array or vector of matrices. all of the matrices must have the same number of rows and the same depth. output array. It has the same number of rows and depth as the src, and the sum of cols of the src.

Applies horizontal concatenation to given matrices.

first input array to be considered for horizontal concatenation. second input array to be considered for horizontal concatenation. output array. It has the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2.

Applies vertical concatenation to given matrices.

input array or vector of matrices. all of the matrices must have the same number of cols and the same depth. output array. It has the same number of cols and depth as the src, and the sum of rows of the src.

Applies vertical concatenation to given matrices.

first input array to be considered for vertical concatenation. second input array to be considered for vertical concatenation. output array. It has the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2.

computes bitwise conjunction of the two arrays (dst = src1 & src2)

first input array or a scalar. second input array or a scalar. output array that has the same size and type as the input optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

computes bitwise disjunction of the two arrays (dst = src1 | src2)

computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)

inverts each bit of array (dst = ~src)

input array. output array that has the same size and type as the input optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

Calculates the per-element absolute difference between two arrays or between an array and a scalar.

first input array or a scalar. second input array or a scalar. output array that has the same size and type as input arrays.

Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.

Source matrix. Destination matrix. If it does not have a proper size or type before the operation, it is reallocated. Operation mask of the same size as \*this. Its non-zero elements indicate which matrix elements need to be copied.The mask has to be of type CV_8U and can have 1 or multiple channels.

Checks if array elements lie between the elements of two other arrays.

first input array. inclusive lower boundary array or a scalar. inclusive upper boundary array or a scalar. output array of the same size as src and CV_8U type.

Checks if array elements lie between the elements of two other arrays.

first input array. inclusive lower boundary array or a scalar. inclusive upper boundary array or a scalar. output array of the same size as src and CV_8U type.

Performs the per-element comparison of two arrays or an array and scalar value.

first input array or a scalar; when it is an array, it must have a single channel. second input array or a scalar; when it is an array, it must have a single channel. output array of type ref CV_8U that has the same size and the same number of channels as the input arrays. a flag, that specifies correspondence between the arrays (cv::CmpTypes)

computes per-element minimum of two arrays (dst = min(src1, src2))

computes per-element minimum of array and scalar (dst = min(src1, src2))

computes per-element maximum of two arrays (dst = max(src1, src2))

computes per-element maximum of array and scalar (dst = max(src1, src2))

computes square root of each matrix element (dst = src**0.5)

The source floating-point array The destination array; will have the same size and the same type as src

raises the input matrix elements to the specified power (b = a**power)

The source array The exponent of power The destination array; will have the same size and the same type as src

computes exponent of each matrix element (dst = e**src)

The source array The destination array; will have the same size and same type as src

computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))

The source array The destination array; will have the same size and same type as src

Calculates x and y coordinates of 2D vectors from their magnitude and angle.

input floating-point array of magnitudes of 2D vectors; it can be an empty matrix(=Mat()), in this case, the function assumes that all the magnitudes are = 1; if it is not empty, it must have the same size and type as angle. input floating-point array of angles of 2D vectors. output array of x-coordinates of 2D vectors; it has the same size and type as angle. output array of y-coordinates of 2D vectors; it has the same size and type as angle. when true, the input angles are measured in degrees, otherwise, they are measured in radians.

Calculates the magnitude and angle of 2D vectors.

array of x-coordinates; this must be a single-precision or double-precision floating-point array. array of y-coordinates, that must have the same size and same type as x. output array of magnitudes of the same size and type as x. output array of angles that has the same size and type as x; the angles are measured in radians(from 0 to 2\*Pi) or in degrees(0 to 360 degrees). a flag, indicating whether the angles are measured in radians(which is by default), or in degrees.

Calculates the rotation angle of 2D vectors.

input floating-point array of x-coordinates of 2D vectors. input array of y-coordinates of 2D vectors; it must have the same size and the same type as x. output array of vector angles; it has the same size and same type as x. when true, the function calculates the angle in degrees, otherwise, they are measured in radians.

Calculates the magnitude of 2D vectors.

floating-point array of x-coordinates of the vectors. floating-point array of y-coordinates of the vectors; it must have the same size as x. output array of the same size and type as x.

checks that each matrix element is within the specified range.

The array to check The flag indicating whether the functions quietly return false when the array elements are out of range, or they throw an exception.

checks that each matrix element is within the specified range.

The array to check The flag indicating whether the functions quietly return false when the array elements are out of range, or they throw an exception. The optional output parameter, where the position of the first outlier is stored. The inclusive lower boundary of valid values range The exclusive upper boundary of valid values range

converts NaN's to the given number

implements generalized matrix product algorithm GEMM from BLAS

multiplies matrix by its transposition from the left or from the right

The source matrix The destination square matrix Specifies the multiplication ordering; see the description below The optional delta matrix, subtracted from src before the multiplication. When the matrix is empty ( delta=Mat() ), it’s assumed to be zero, i.e. nothing is subtracted, otherwise if it has the same size as src, then it’s simply subtracted, otherwise it is "repeated" to cover the full src and then subtracted. Type of the delta matrix, when it's not empty, must be the same as the type of created destination matrix, see the rtype description The optional scale factor for the matrix product When it’s negative, the destination matrix will have the same type as src . Otherwise, it will have type=CV_MAT_DEPTH(rtype), which should be either CV_32F or CV_64F

transposes the matrix

The source array The destination array of the same type as src

performs affine transformation of each element of multi-channel input matrix

The source array; must have as many channels (1 to 4) as mtx.cols or mtx.cols-1 The destination array; will have the same size and depth as src and as many channels as mtx.rows The transformation matrix

performs perspective transformation of each element of multi-channel input matrix

The source two-channel or three-channel floating-point array; each element is 2D/3D vector to be transformed The destination array; it will have the same size and same type as src 3x3 or 4x4 transformation matrix

performs perspective transformation of each element of multi-channel input matrix

The source two-channel or three-channel floating-point array; each element is 2D/3D vector to be transformed 3x3 or 4x4 transformation matrix The destination array; it will have the same size and same type as src

performs perspective transformation of each element of multi-channel input matrix

extends the symmetrical matrix from the lower half or from the upper half

Input-output floating-point square matrix If true, the lower half is copied to the upper half, otherwise the upper half is copied to the lower half

initializes scaled identity matrix

The matrix to initialize (not necessarily square) The value to assign to the diagonal elements

computes determinant of a square matrix

The input matrix; must have CV_32FC1 or CV_64FC1 type and square size determinant of the specified matrix.

computes trace of a matrix

The source matrix

computes inverse or pseudo-inverse matrix

The source floating-point MxN matrix The destination matrix; will have NxM size and the same type as src The inversion method

solves linear system or a least-square problem

Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).

This row-vector corresponds to \f$c\f$ in the LP problem formulation (see above). It should contain 32- or 64-bit floating point numbers.As a convenience, column-vector may be also submitted, in the latter case it is understood to correspond to \f$c^T\f$. `m`-by-`n+1` matrix, whose rightmost column corresponds to \f$b\f$ in formulation above and the remaining to \f$A\f$. It should containt 32- or 64-bit floating point numbers. The solution will be returned here as a column-vector - it corresponds to \f$c\f$ in the formulation above.It will contain 64-bit floating point numbers.

sorts independently each matrix row or each matrix column

The source single-channel array The destination array of the same size and the same type as src The operation flags, a combination of the SortFlag values

sorts independently each matrix row or each matrix column

The source single-channel array The destination integer array of the same size as src The operation flags, a combination of SortFlag values

finds real roots of a cubic polynomial

The equation coefficients, an array of 3 or 4 elements The destination array of real roots which will have 1 or 3 elements

finds real and complex roots of a polynomial

The array of polynomial coefficients The destination (complex) array of roots The maximum number of iterations the algorithm does

Computes eigenvalues and eigenvectors of a symmetric matrix.

The input matrix; must have CV_32FC1 or CV_64FC1 type, square size and be symmetric: src^T == src The output vector of eigenvalues of the same type as src; The eigenvalues are stored in the descending order. The output matrix of eigenvectors; It will have the same size and the same type as src; The eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues

Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).

input matrix (CV_32FC1 or CV_64FC1 type). output vector of eigenvalues (type is the same type as src). output matrix of eigenvectors (type is the same type as src). The eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.

computes covariation matrix of a set of samples

samples stored as separate matrices output covariance matrix of the type ctype and square size. input or output (depending on the flags) array as the average value of the input vectors. operation flags as a combination of CovarFlags type of the matrixl; it equals 'CV_64F' by default.

computes covariation matrix of a set of samples

samples stored as rows/columns of a single matrix. output covariance matrix of the type ctype and square size. input or output (depending on the flags) array as the average value of the input vectors. operation flags as a combination of CovarFlags type of the matrixl; it equals 'CV_64F' by default.

PCA of the supplied dataset.

input samples stored as the matrix rows or as the matrix columns. optional mean value; if the matrix is empty (noArray()), the mean is computed from the data. eigenvectors of the covariation matrix maximum number of components that PCA should retain; by default, all the components are retained.

PCA of the supplied dataset.

input samples stored as the matrix rows or as the matrix columns. optional mean value; if the matrix is empty (noArray()), the mean is computed from the data. eigenvectors of the covariation matrix eigenvalues of the covariation matrix maximum number of components that PCA should retain; by default, all the components are retained.

PCA of the supplied dataset.

input samples stored as the matrix rows or as the matrix columns. optional mean value; if the matrix is empty (noArray()), the mean is computed from the data. eigenvectors of the covariation matrix Percentage of variance that PCA should retain. Using this parameter will let the PCA decided how many components to retain but it will always keep at least 2.

PCA of the supplied dataset.

input samples stored as the matrix rows or as the matrix columns. optional mean value; if the matrix is empty (noArray()), the mean is computed from the data. eigenvectors of the covariation matrix eigenvalues of the covariation matrix Percentage of variance that PCA should retain. Using this parameter will let the PCA decided how many components to retain but it will always keep at least 2.

Projects vector(s) to the principal component subspace.

Reconstructs vectors from their PC projections.

decomposes matrix and stores the results to user-provided matrices

decomposed matrix. The depth has to be CV_32F or CV_64F. calculated singular values calculated left singular vectors transposed matrix of right singular vectors peration flags - see SVD::Flags.

performs back substitution for the previously computed SVD

calculated singular values calculated left singular vectors transposed matrix of right singular vectors right-hand side of a linear system (u*w*v')*dst = rhs to be solved, where A has been previously decomposed. output

Calculates the Mahalanobis distance between two vectors.

first 1D input vector. second 1D input vector. inverse covariance matrix.

Performs a forward Discrete Fourier transform of 1D or 2D floating-point array.

The source array, real or complex The destination array, which size and type depends on the flags Transformation flags, a combination of the DftFlag2 values When the parameter != 0, the function assumes that only the first nonzeroRows rows of the input array ( DFT_INVERSE is not set) or only the first nonzeroRows of the output array ( DFT_INVERSE is set) contain non-zeros, thus the function can handle the rest of the rows more efficiently and thus save some time. This technique is very useful for computing array cross-correlation or convolution using DFT

Performs an inverse Discrete Fourier transform of 1D or 2D floating-point array.

Performs forward or inverse 1D or 2D Discrete Cosine Transformation

The source floating-point array The destination array; will have the same size and same type as src Transformation flags, a combination of DctFlag2 values

Performs inverse 1D or 2D Discrete Cosine Transformation

The source floating-point array The destination array; will have the same size and same type as src Transformation flags, a combination of DctFlag2 values

Performs the per-element multiplication of two Fourier spectrums.

first input array. second input array of the same size and type as src1. output array of the same size and type as src1. operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a `0` as value. optional flag that conjugates the second input array before the multiplication (true) or not (false).

Returns the optimal DFT size for a given vector size.

vector size.

Returns the thread-local Random number generator

Sets the thread-local Random number generator

fills array with uniformly-distributed random numbers from the range [low, high)

The output array of random numbers. The array must be pre-allocated and have 1 to 4 channels The inclusive lower boundary of the generated random numbers The exclusive upper boundary of the generated random numbers

fills array with uniformly-distributed random numbers from the range [low, high)

fills array with normally-distributed random numbers with the specified mean and the standard deviation

The output array of random numbers. The array must be pre-allocated and have 1 to 4 channels The mean value (expectation) of the generated random numbers The standard deviation of the generated random numbers

fills array with normally-distributed random numbers with the specified mean and the standard deviation

shuffles the input array elements

The input/output numerical 1D array The scale factor that determines the number of random swap operations.

shuffles the input array elements

The input/output numerical 1D array The scale factor that determines the number of random swap operations. The optional random number generator used for shuffling. If it is null, theRng() is used instead.

Finds centers of clusters and groups input samples around the clusters.

Data for clustering. An array of N-Dimensional points with float coordinates is needed. Number of clusters to split the set by. Input/output integer array that stores the cluster indices for every sample. The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops. Flag to specify the number of times the algorithm is executed using different initial labellings. The algorithm returns the labels that yield the best compactness (see the last function parameter). Flag that can take values of cv::KmeansFlags Output matrix of the cluster centers, one row per each cluster center. The function returns the compactness measure that is computed as \f[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\f] after every attempt. The best (minimum) value is chosen and the corresponding labels and the compactness value are returned by the function. Basically, you can use only the core of the function, set the number of attempts to 1, initialize labels each time using a custom algorithm, pass them with the ( flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering.

computes the angle in degrees (0..360) of the vector (x,y)

computes cube root of the argument

OpenCV will try to set the number of threads for the next parallel region. If threads == 0, OpenCV will disable threading optimizations and run all it's functions sequentially.Passing threads < 0 will reset threads number to system default. This function must be called outside of parallel region. OpenCV will try to run its functions with specified threads number, but some behaviour differs from framework: - `TBB` - User-defined parallel constructions will run with the same threads number, if another is not specified.If later on user creates his own scheduler, OpenCV will use it. - `OpenMP` - No special defined behaviour. - `Concurrency` - If threads == 1, OpenCV will disable threading optimizations and run its functions sequentially. - `GCD` - Supports only values <= 0. - `C=` - No special defined behaviour.

Number of threads used by OpenCV.

Returns the number of threads used by OpenCV for parallel regions. Always returns 1 if OpenCV is built without threading support. The exact meaning of return value depends on the threading framework used by OpenCV library: - `TBB` - The number of threads, that OpenCV will try to use for parallel regions. If there is any tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns default number of threads used by TBB library. - `OpenMP` - An upper bound on the number of threads that could be used to form a new team. - `Concurrency` - The number of threads, that OpenCV will try to use for parallel regions. - `GCD` - Unsupported; returns the GCD thread pool limit(512) for compatibility. - `C=` - The number of threads, that OpenCV will try to use for parallel regions, if before called setNumThreads with threads > 0, otherwise returns the number of logical CPUs, available for the process.

Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region. @deprecated Current implementation doesn't corresponding to this documentation. The exact meaning of the return value depends on the threading framework used by OpenCV library: - `TBB` - Unsupported with current 4.1 TBB release.Maybe will be supported in future. - `OpenMP` - The thread number, within the current team, of the calling thread. - `Concurrency` - An ID for the virtual processor that the current context is executing on(0 for master thread and unique number for others, but not necessary 1,2,3,...). - `GCD` - System calling thread's ID. Never returns 0 inside parallel region. - `C=` - The index of the current parallel task.

Returns full configuration time cmake output. Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc.Output format depends on target architecture.

Returns library version string. For example "3.4.1-dev".

Returns major library version

Returns minor library version

Returns revision field of the library version

Returns the number of ticks. The function returns the number of ticks after the certain event (for example, when the machine was turned on). It can be used to initialize RNG or to measure a function execution time by reading the tick count before and after the function call.

Returns the number of ticks per second. The function returns the number of ticks per second.That is, the following code computes the execution time in seconds:

Returns the number of CPU ticks. The function returns the current number of CPU ticks on some architectures(such as x86, x64, PowerPC). On other platforms the function is equivalent to getTickCount.It can also be used for very accurate time measurements, as well as for RNG initialization.Note that in case of multi-CPU systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU with its own counter. So, theoretically (and practically) the subsequent calls to the function do not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU frequency depending on the load, the number of CPU clocks spent in some code cannot be directly converted to time units.Therefore, getTickCount is generally a preferable solution for measuringexecution time.

Returns true if the specified feature is supported by the host hardware. The function returns true if the host hardware supports the specified feature.When user calls setUseOptimized(false), the subsequent calls to checkHardwareSupport() will return false until setUseOptimized(true) is called.This way user can dynamically switch on and off the optimized code in OpenCV.

The feature of interest, one of cv::CpuFeatures

Returns feature name by ID. Returns empty string if feature is not defined

Returns list of CPU features enabled during compilation. Returned value is a string containing space separated list of CPU features with following markers: - no markers - baseline features - prefix `*` - features enabled in dispatcher - suffix `?` - features enabled but not available in HW

`SSE SSE2 SSE3* SSE4.1 *SSE4.2 *FP16* AVX *AVX2* AVX512-SKX?`

Returns the number of logical CPUs available for the process.

Turns on/off available optimization. The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.

Returns the current optimization status. The function returns the current optimization status, which is controlled by cv::setUseOptimized().

Aligns buffer size by the certain number of bytes This small inline function aligns a buffer size by the certian number of bytes by enlarging it.

Sets/resets the break-on-error mode. When the break-on-error mode is set, the default error handler issues a hardware exception, which can make debugging more convenient.

the previous state

Set global logging level

logging level previous logging level

Get global logging level

logging level

Computes absolute value of each matrix element

matrix

Computes absolute value of each matrix element

matrix expression

Equivalence predicate (a boolean function of two arguments). The predicate returns true when the elements are certainly in the same class, and returns false if they may or may not be in the same class.

Splits an element set into equivalency classes. Consider using GroupBy of Linq instead.

Set of elements stored as a vector. Output vector of labels. It contains as many elements as vec. Each label labels[i] is a 0-based cluster index of vec[i] . Equivalence predicate (a boolean function of two arguments). The predicate returns true when the elements are certainly in the same class, and returns false if they may or may not be in the same class.

Detects corners using the FAST algorithm

grayscale image where keypoints (corners) are detected. threshold on difference between intensity of the central pixel and pixels of a circle around this pixel. if true, non-maximum suppression is applied to detected corners (keypoints). keypoints detected on the image.

Detects corners using the FAST algorithm

Detects corners using the AGAST algorithm

Draw keypoints.

Source image. Keypoints from the source image. Output image. Its content depends on the flags value defining what is drawn in the output image. See possible flags bit values below. Color of keypoints. Flags setting drawing features. Possible flags bit values are defined by DrawMatchesFlags.

Draws the found matches of keypoints from two images.

First source image. Keypoints from the first source image. Second source image. Keypoints from the second source image. Matches from the first image to the second one, which means that keypoints1[i] has a corresponding point in keypoints2[matches[i]] . Output image. Its content depends on the flags value defining what is drawn in the output image. See possible flags bit values below. Color of matches (lines and connected keypoints). If matchColor==Scalar::all(-1), the color is generated randomly. Color of single keypoints (circles), which means that keypoints do not have the matches. If singlePointColor==Scalar::all(-1) , the color is generated randomly. Mask determining which matches are drawn. If the mask is empty, all matches are drawn. Flags setting drawing features. Possible flags bit values are defined by DrawMatchesFlags.

Draws the found matches of keypoints from two images.

recallPrecisionCurve

Creates a window.

Name of the window in the window caption that may be used as a window identifier. Flags of the window. Currently the only supported flag is CV WINDOW AUTOSIZE. If this is set, the window size is automatically adjusted to fit the displayed image (see imshow ), and the user can not change the window size manually.

Destroys the specified window.

Destroys all of the HighGUI windows.

Waits for a pressed key. Similar to #waitKey, but returns full key code. Key code is implementation specific and depends on used backend: QT/GTK/Win32/etc

Delay in milliseconds. 0 is the special value that means ”forever” Returns the code of the pressed key or -1 if no key was pressed before the specified time had elapsed.

Waits for a pressed key.

Delay in milliseconds. 0 is the special value that means ”forever” Returns the code of the pressed key or -1 if no key was pressed before the specified time had elapsed.

Displays the image in the specified window

Name of the window. Image to be shown.

Resizes window to the specified size

Window name The new window width The new window height

Resizes window to the specified size

Window name The new window size

Moves window to the specified position

Window name The new x-coordinate of the window The new y-coordinate of the window

Changes parameters of a window dynamically.

Name of the window. Window property to retrieve. New value of the window property.

Updates window title

Name of the window New title

Provides parameters of a window.

Name of the window. Window property to retrieve.

Provides rectangle of image in the window. The function getWindowImageRect returns the client screen coordinates, width and height of the image rendering area.

Name of the window.

Sets the callback function for mouse events occuring within the specified window.

Name of the window. Reference to the function to be called every time mouse event occurs in the specified window.

Gets the mouse-wheel motion delta, when handling mouse-wheel events cv::EVENT_MOUSEWHEEL and cv::EVENT_MOUSEHWHEEL. For regular mice with a scroll-wheel, delta will be a multiple of 120. The value 120 corresponds to a one notch rotation of the wheel or the threshold for action to be taken and one such action should occur for each delta.Some high-precision mice with higher-resolution freely-rotating wheels may generate smaller values. For cv::EVENT_MOUSEWHEEL positive and negative values mean forward and backward scrolling, respectively.For cv::EVENT_MOUSEHWHEEL, where available, positive and negative values mean right and left scrolling, respectively.

The mouse callback flags parameter.

Selects ROI on the given image. Function creates a window and allows user to select a ROI using mouse. Controls: use `space` or `enter` to finish selection, use key `c` to cancel selection (function will return the zero cv::Rect).

name of the window where selection process will be shown. image to select a ROI. if true crosshair of selection rectangle will be shown. if true center of selection will match initial mouse position. In opposite case a corner of selection rectangle will correspond to the initial mouse position. selected ROI or empty rect if selection canceled.

image to select a ROI. if true crosshair of selection rectangle will be shown. if true center of selection will match initial mouse position. In opposite case a corner of selection rectangle will correspond to the initial mouse position. selected ROI or empty rect if selection canceled.

Selects ROIs on the given image. Function creates a window and allows user to select a ROIs using mouse. Controls: use `space` or `enter` to finish current selection and start a new one, use `esc` to terminate multiple ROI selection process.

Creates a trackbar and attaches it to the specified window. The function createTrackbar creates a trackbar(a slider or range control) with the specified name and range, assigns a variable value to be a position synchronized with the trackbar and specifies the callback function onChange to be called on the trackbar position change.The created trackbar is displayed in the specified window winName.

Name of the created trackbar. Name of the window that will be used as a parent of the created trackbar. Optional pointer to an integer variable whose value reflects the position of the slider.Upon creation, the slider position is defined by this variable. Maximal position of the slider. The minimal position is always 0. Pointer to the function to be called every time the slider changes position. This function should be prototyped as void Foo(int, void\*); , where the first parameter is the trackbar position and the second parameter is the user data(see the next parameter). If the callback is the NULL pointer, no callbacks are called, but only value is updated. User data that is passed as is to the callback. It can be used to handle trackbar events without using global variables.

Name of the created trackbar. Name of the window that will be used as a parent of the created trackbar. Maximal position of the slider. The minimal position is always 0. Pointer to the function to be called every time the slider changes position. This function should be prototyped as void Foo(int, void\*); , where the first parameter is the trackbar position and the second parameter is the user data(see the next parameter). If the callback is the NULL pointer, no callbacks are called, but only value is updated. User data that is passed as is to the callback. It can be used to handle trackbar events without using global variables.

Returns the trackbar position.

Name of the trackbar. Name of the window that is the parent of the trackbar. trackbar position

Sets the trackbar position.

Name of the trackbar. Name of the window that is the parent of trackbar. New position.

Sets the trackbar maximum position. The function sets the maximum position of the specified trackbar in the specified window.

Name of the trackbar. Name of the window that is the parent of trackbar. New maximum position.

Sets the trackbar minimum position. The function sets the minimum position of the specified trackbar in the specified window.

Name of the trackbar. Name of the window that is the parent of trackbar. New minimum position.

get native window handle (HWND in case of Win32 and Widget in case of X Window)

Loads an image from a file.

Name of file to be loaded. Specifies color type of the loaded image

Loads a multi-page image from a file.

Name of file to be loaded. A vector of Mat objects holding each page, if more than one. Flag that can take values of @ref cv::ImreadModes, default with IMREAD_ANYCOLOR.

Saves an image to a specified file.

Name of the file. Image to be saved. Format-specific save parameters encoded as pairs

Saves an image to a specified file.

Name of the file. Image to be saved. Format-specific save parameters encoded as pairs

Saves an image to a specified file.

Name of the file. Image to be saved. Format-specific save parameters encoded as pairs

Saves an image to a specified file.

Name of the file. Image to be saved. Format-specific save parameters encoded as pairs

Reads image from the specified buffer in memory.

The input array of vector of bytes. The same flags as in imread

Reads image from the specified buffer in memory.

The input array of vector of bytes. The same flags as in imread

Reads image from the specified buffer in memory.

The input array of vector of bytes. The same flags as in imread

Reads image from the specified buffer in memory.

The input slice of bytes. The same flags as in imread

Compresses the image and stores it in the memory buffer

The file extension that defines the output format The image to be written Output buffer resized to fit the compressed image. Format-specific parameters.

Compresses the image and stores it in the memory buffer

The file extension that defines the output format The image to be written Output buffer resized to fit the compressed image. Format-specific parameters.

Returns Gaussian filter coefficients.

Aperture size. It should be odd and positive. Gaussian standard deviation. If it is non-positive, it is computed from ksize as `sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8`. Type of filter coefficients. It can be CV_32F or CV_64F.

Returns filter coefficients for computing spatial image derivatives.

Output matrix of row filter coefficients. It has the type ktype. Output matrix of column filter coefficients. It has the type ktype. Derivative order in respect of x. Derivative order in respect of y. Aperture size. It can be CV_SCHARR, 1, 3, 5, or 7. Flag indicating whether to normalize (scale down) the filter coefficients or not. Theoretically, the coefficients should have the denominator \f$=2^{ksize*2-dx-dy-2}\f$. If you are going to filter floating-point images, you are likely to use the normalized kernels. But if you compute derivatives of an 8-bit image, store the results in a 16-bit image, and wish to preserve all the fractional bits, you may want to set normalize = false. Type of filter coefficients. It can be CV_32f or CV_64F.

Returns Gabor filter coefficients.

For more details about gabor filter equations and parameters, see: https://en.wikipedia.org/wiki/Gabor_filter Size of the filter returned. Standard deviation of the gaussian envelope. Orientation of the normal to the parallel stripes of a Gabor function. Wavelength of the sinusoidal factor. Spatial aspect ratio. Phase offset. Type of filter coefficients. It can be CV_32F or CV_64F.

Returns a structuring element of the specified size and shape for morphological operations. The function constructs and returns the structuring element that can be further passed to erode, dilate or morphologyEx.But you can also construct an arbitrary binary mask yourself and use it as the structuring element.

Element shape that could be one of MorphShapes Size of the structuring element.

Element shape that could be one of MorphShapes Size of the structuring element. Anchor position within the element. The default value (−1,−1) means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted.

Smoothes image using median filter

The source 1-, 3- or 4-channel image. When ksize is 3 or 5, the image depth should be CV_8U , CV_16U or CV_32F. For larger aperture sizes it can only be CV_8U The destination array; will have the same size and the same type as src The aperture linear size. It must be odd and more than 1, i.e. 3, 5, 7 ...

Blurs an image using a Gaussian filter.

input image; the image can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F. output image of the same size and type as src. Gaussian kernel size. ksize.width and ksize.height can differ but they both must be positive and odd. Or, they can be zero’s and then they are computed from sigma* . Gaussian kernel standard deviation in X direction. Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height, respectively (see getGaussianKernel() for details); to fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize, sigmaX, and sigmaY. pixel extrapolation method

Applies bilateral filter to the image

The source 8-bit or floating-point, 1-channel or 3-channel image The destination image; will have the same size and the same type as src The diameter of each pixel neighborhood, that is used during filtering. If it is non-positive, it's computed from sigmaSpace Filter sigma in the color space. Larger value of the parameter means that farther colors within the pixel neighborhood will be mixed together, resulting in larger areas of semi-equal color Filter sigma in the coordinate space. Larger value of the parameter means that farther pixels will influence each other (as long as their colors are close enough; see sigmaColor). Then d>0 , it specifies the neighborhood size regardless of sigmaSpace, otherwise d is proportional to sigmaSpace

Smoothes image using box filter

The source image The destination image; will have the same size and the same type as src The smoothing kernel size The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center Indicates, whether the kernel is normalized by its area or not The border mode used to extrapolate pixels outside of the image

Calculates the normalized sum of squares of the pixel values overlapping the filter. For every pixel f(x, y) in the source image, the function calculates the sum of squares of those neighboring pixel values which overlap the filter placed over the pixel f(x, y). The unnormalized square box filter can be useful in computing local image statistics such as the the local variance and standard deviation around the neighborhood of a pixel.

Smoothes image using normalized box filter

The source image The destination image; will have the same size and the same type as src The smoothing kernel size The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center The border mode used to extrapolate pixels outside of the image

Convolves an image with the kernel

The source image The destination image. It will have the same size and the same number of channels as src The desired depth of the destination image. If it is negative, it will be the same as src.depth() Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using split() and process them individually The anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center The optional value added to the filtered pixels before storing them in dst The pixel extrapolation method

Applies separable linear filter to an image

The source image The destination image; will have the same size and the same number of channels as src The destination image depth The coefficients for filtering each row The coefficients for filtering each column The anchor position within the kernel; The default value (-1, 1) means that the anchor is at the kernel center The value added to the filtered results before storing them The pixel extrapolation method

Calculates the first, second, third or mixed image derivatives using an extended Sobel operator

The source image The destination image; will have the same size and the same number of channels as src The destination image depth Order of the derivative x Order of the derivative y Size of the extended Sobel kernel, must be 1, 3, 5 or 7 The optional scale factor for the computed derivative values (by default, no scaling is applied The optional delta value, added to the results prior to storing them in dst The pixel extrapolation method

Calculates the first order image derivative in both x and y using a Sobel operator

input image. output image with first-order derivative in x. output image with first-order derivative in y. size of Sobel kernel. It must be 3. pixel extrapolation method

Calculates the first x- or y- image derivative using Scharr operator

The source image The destination image; will have the same size and the same number of channels as src The destination image depth Order of the derivative x Order of the derivative y The optional scale factor for the computed derivative values (by default, no scaling is applie The optional delta value, added to the results prior to storing them in dst The pixel extrapolation method

Calculates the Laplacian of an image

Source image Destination image; will have the same size and the same number of channels as src The desired depth of the destination image The aperture size used to compute the second-derivative filters The optional scale factor for the computed Laplacian values (by default, no scaling is applied The optional delta value, added to the results prior to storing them in dst The pixel extrapolation method

Finds edges in an image using Canny algorithm.

Single-channel 8-bit input image The output edge map. It will have the same size and the same type as image The first threshold for the hysteresis procedure The second threshold for the hysteresis procedure Aperture size for the Sobel operator [By default this is ApertureSize.Size3] Indicates, whether the more accurate L2 norm should be used to compute the image gradient magnitude (true), or a faster default L1 norm is enough (false). [By default this is false]

Finds edges in an image using the Canny algorithm with custom image gradient.

16-bit x derivative of input image (CV_16SC1 or CV_16SC3). 16-bit y derivative of input image (same type as dx). output edge map; single channels 8-bit image, which has the same size as image. first threshold for the hysteresis procedure. second threshold for the hysteresis procedure. Indicates, whether the more accurate L2 norm should be used to compute the image gradient magnitude (true), or a faster default L1 norm is enough (false). [By default this is false]

Calculates the minimal eigenvalue of gradient matrices for corner detection.

Input single-channel 8-bit or floating-point image. Image to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as src . Neighborhood size (see the details on #cornerEigenValsAndVecs ). Aperture parameter for the Sobel operator. Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

Harris corner detector.

Input single-channel 8-bit or floating-point image. Image to store the Harris detector responses. It has the type CV_32FC1 and the same size as src. Neighborhood size (see the details on #cornerEigenValsAndVecs ). Aperture parameter for the Sobel operator. Harris detector free parameter. See the formula above. Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.

computes another complex cornerness criteria at each pixel

adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria

Input image. Initial coordinates of the input corners and refined coordinates provided for output. Half of the side length of the search window. Half of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such a size. Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after criteria.maxCount iterations or when the corner position moves by less than criteria.epsilon on some iteration.

finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima

Input 8-bit or floating-point 32-bit, single-channel image. Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned. Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue or the Harris function response (see cornerHarris() ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the qualityLevel=0.01, then all the corners with the quality measure less than 15 are rejected. Minimum possible Euclidean distance between the returned corners. Optional region of interest. If the image is not empty (it needs to have the type CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected. Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. Parameter indicating whether to use a Harris detector Free parameter of the Harris detector. Output vector of detected corners.

Finds lines in a binary image using standard Hough transform.

The 8-bit, single-channel, binary source image. The image may be modified by the function Distance resolution of the accumulator in pixels Angle resolution of the accumulator in radians The accumulator threshold parameter. Only those lines are returned that get enough votes ( > threshold ) For the multi-scale Hough transform it is the divisor for the distance resolution rho. [By default this is 0] For the multi-scale Hough transform it is the divisor for the distance resolution theta. [By default this is 0] The output vector of lines. Each line is represented by a two-element vector (rho, theta) . rho is the distance from the coordinate origin (0,0) (top-left corner of the image) and theta is the line rotation angle in radians

Finds lines segments in a binary image using probabilistic Hough transform.

Distance resolution of the accumulator in pixels Angle resolution of the accumulator in radians The accumulator threshold parameter. Only those lines are returned that get enough votes ( > threshold ) The minimum line length. Line segments shorter than that will be rejected. [By default this is 0] The maximum allowed gap between points on the same line to link them. [By default this is 0] The output lines. Each line is represented by a 4-element vector (x1, y1, x2, y2)

Finds lines in a set of points using the standard Hough transform. The function finds lines in a set of points using a modification of the Hough transform.

Input vector of points. Each vector must be encoded as a Point vector \f$(x,y)\f$. Type must be CV_32FC2 or CV_32SC2. Output vector of found lines. Each vector is encoded as a vector<Vec3d> Max count of hough lines. Accumulator threshold parameter. Only those lines are returned that get enough votes Minimum Distance value of the accumulator in pixels. Maximum Distance value of the accumulator in pixels. Distance resolution of the accumulator in pixels. Minimum angle value of the accumulator in radians. Maximum angle value of the accumulator in radians. Angle resolution of the accumulator in radians.

Finds circles in a grayscale image using a Hough transform.

The 8-bit, single-channel, grayscale input image The available methods are HoughMethods.Gradient and HoughMethods.GradientAlt The inverse ratio of the accumulator resolution to the image resolution. Minimum distance between the centers of the detected circles. The first method-specific parameter. [By default this is 100] The second method-specific parameter. [By default this is 100] Minimum circle radius. [By default this is 0] Maximum circle radius. [By default this is 0] The output vector found circles. Each vector is encoded as 3-element floating-point vector (x, y, radius)

Default borderValue for Dilate/Erode

Dilates an image by using a specific structuring element.

The source image The destination image. It will have the same size and the same type as src The structuring element used for dilation. If element=new Mat() , a 3x3 rectangular structuring element is used Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center The number of times dilation is applied. [By default this is 1] The pixel extrapolation method. [By default this is BorderType.Constant] The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]

Erodes an image by using a specific structuring element.

The source image The destination image. It will have the same size and the same type as src The structuring element used for dilation. If element=new Mat(), a 3x3 rectangular structuring element is used Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center The number of times erosion is applied The pixel extrapolation method The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]

Performs advanced morphological transformations

Source image Destination image. It will have the same size and the same type as src Type of morphological operation Structuring element Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center Number of times erosion and dilation are applied. [By default this is 1] The pixel extrapolation method. [By default this is BorderType.Constant] The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]

Resizes an image.

input image. output image; it has the size dsize (when it is non-zero) or the size computed from src.size(), fx, and fy; the type of dst is the same as of src. output image size; if it equals zero, it is computed as: dsize = Size(round(fx*src.cols), round(fy*src.rows)) Either dsize or both fx and fy must be non-zero. scale factor along the horizontal axis; when it equals 0, it is computed as: (double)dsize.width/src.cols scale factor along the vertical axis; when it equals 0, it is computed as: (double)dsize.height/src.rows interpolation method

Applies an affine transformation to an image.

input image. output image that has the size dsize and the same type as src. 2x3 transformation matrix. size of the output image. combination of interpolation methods and the optional flag WARP_INVERSE_MAP that means that M is the inverse transformation (dst -> src) . pixel extrapolation method; when borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function. value used in case of a constant border; by default, it is 0.

Applies a perspective transformation to an image.

input image. output image that has the size dsize and the same type as src. 3x3 transformation matrix. size of the output image. combination of interpolation methods (INTER_LINEAR or INTER_NEAREST) and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation (dst -> src). pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE). value used in case of a constant border; by default, it equals 0.

Applies a perspective transformation to an image.

Applies a generic geometrical transformation to an image.

Source image. Destination image. It has the same size as map1 and the same type as src The first map of either (x,y) points or just x values having the type CV_16SC2, CV_32FC1, or CV_32FC2. The second map of y values having the type CV_16UC1, CV_32FC1, or none (empty map if map1 is (x,y) points), respectively. Interpolation method. The method INTER_AREA is not supported by this function. Pixel extrapolation method. When borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function. Value used in case of a constant border. By default, it is 0.

Converts image transformation maps from one representation to another.

The first input map of type CV_16SC2 , CV_32FC1 , or CV_32FC2 . The second input map of type CV_16UC1 , CV_32FC1 , or none (empty matrix), respectively. The first output map that has the type dstmap1type and the same size as src. The second output map. Type of the first output map that should be CV_16SC2 , CV_32FC1 , or CV_32FC2 . Flag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.

Calculates an affine matrix of 2D rotation.

Center of the rotation in the source image. Rotation angle in degrees. Positive values mean counter-clockwise rotation (the coordinate origin is assumed to be the top-left corner). Isotropic scale factor.

Inverts an affine transformation.

Original affine transformation. Output reverse affine transformation.

Calculates a perspective transform from four pairs of the corresponding points. The function calculates the 3×3 matrix of a perspective transform.

Coordinates of quadrangle vertices in the source image. Coordinates of the corresponding quadrangle vertices in the destination image.

Calculates a perspective transform from four pairs of the corresponding points. The function calculates the 3×3 matrix of a perspective transform.

Coordinates of quadrangle vertices in the source image. Coordinates of the corresponding quadrangle vertices in the destination image.

Calculates an affine transform from three pairs of the corresponding points. The function calculates the 2×3 matrix of an affine transform.

Coordinates of triangle vertices in the source image. Coordinates of the corresponding triangle vertices in the destination image.

Calculates an affine transform from three pairs of the corresponding points. The function calculates the 2×3 matrix of an affine transform.

Coordinates of triangle vertices in the source image. Coordinates of the corresponding triangle vertices in the destination image.

Retrieves a pixel rectangle from an image with sub-pixel accuracy.

Source image. Size of the extracted patch. Floating point coordinates of the center of the extracted rectangle within the source image. The center must be inside the image. Extracted patch that has the size patchSize and the same number of channels as src . Depth of the extracted pixels. By default, they have the same depth as src.

Remaps an image to log-polar space.

Source image Destination image The transformation center; where the output precision is maximal Magnitude scale parameter. A combination of interpolation methods, see cv::InterpolationFlags

Remaps an image to polar space.

Source image Destination image The transformation center Inverse magnitude scale parameter A combination of interpolation methods, see cv::InterpolationFlags

Remaps an image to polar or semilog-polar coordinates space.

- The function can not operate in-place. - To calculate magnitude and angle in degrees #cartToPolar is used internally thus angles are measured from 0 to 360 with accuracy about 0.3 degrees. - This function uses #remap. Due to current implementation limitations the size of an input and output images should be less than 32767x32767. Source image. Destination image. It will have same type as src. The destination image size (see description for valid options). The transformation center. The radius of the bounding circle to transform. It determines the inverse magnitude scale parameter too. interpolation methods. interpolation methods.

Calculates the integral of an image. The function calculates one or more integral images for the source image.

input image as W×H, 8-bit or floating-point (32f or 64f). integral image as (W+1)×(H+1) , 32-bit integer or floating-point (32f or 64f). integral image for squared pixel values; it is (W+1)×(H+1), double-precision floating-point (64f) array. integral for the image rotated by 45 degrees; it is (W+1)×(H+1) array with the same data type as sum. desired depth of the integral and the tilted integral images, CV_32S, CV_32F, or CV_64F. desired depth of the integral image of squared pixel values, CV_32F or CV_64F.

Adds an image to the accumulator.

Input image as 1- or 3-channel, 8-bit or 32-bit floating point. Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point. Optional operation mask.

Adds the square of a source image to the accumulator.

Input image as 1- or 3-channel, 8-bit or 32-bit floating point. Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point. Optional operation mask.

Adds the per-element product of two input images to the accumulator.

First input image, 1- or 3-channel, 8-bit or 32-bit floating point. Second input image of the same type and the same size as src1 Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point. Optional operation mask.

Updates a running average.

Input image as 1- or 3-channel, 8-bit or 32-bit floating point. Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point. Weight of the input image. Optional operation mask.

The function is used to detect translational shifts that occur between two images. The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain.It can be used for fast image registration as well as motion estimation. For more information please see http://en.wikipedia.org/wiki/Phase_correlation. Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.

Source floating point array (CV_32FC1 or CV_64FC1) Source floating point array (CV_32FC1 or CV_64FC1) Floating point array with windowing coefficients to reduce edge effects (optional). Signal power within the 5x5 centroid around the peak, between 0 and 1 (optional). detected phase shift(sub-pixel) between the two arrays.

Computes a Hanning window coefficients in two dimensions.

Destination array to place Hann coefficients in The window size specifications Created array type

Applies a fixed-level threshold to each array element.

input array (single-channel, 8-bit or 32-bit floating point). output array of the same size and type as src. threshold value. maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types. thresholding type (see the details below). the computed threshold value when type == OTSU

Applies an adaptive threshold to an array.

Source 8-bit single-channel image. Destination image of the same size and the same type as src . Non-zero value assigned to the pixels for which the condition is satisfied. See the details below. Adaptive thresholding algorithm to use, ADAPTIVE_THRESH_MEAN_C or ADAPTIVE_THRESH_GAUSSIAN_C . Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV . Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on. Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.

Blurs an image and downsamples it.

input image. output image; it has the specified size and the same type as src. size of the output image; by default, it is computed as Size((src.cols+1)/2

Upsamples an image and then blurs it.

input image. output image. It has the specified size and the same type as src. size of the output image; by default, it is computed as Size(src.cols*2, (src.rows*2)

computes the joint dense histogram for a set of images.

compares two histograms stored in dense arrays

The first compared histogram The second compared histogram of the same size as h1 The comparison method

normalizes the grayscale image brightness and contrast by normalizing its histogram

The source 8-bit single channel image The destination image; will have the same size and the same type as src

Creates a predefined CLAHE object

Computes the "minimal work" distance between two weighted point configurations. The function computes the earth mover distance and/or a lower boundary of the distance between the two weighted point configurations.One of the applications described in @cite RubnerSept98, @cite Rubner2000 is multi-dimensional histogram comparison for image retrieval.EMD is a transportation problem that is solved using some modification of a simplex algorithm, thus the complexity is exponential in the worst case, though, on average it is much faster.In the case of a real metric the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used to determine roughly whether the two signatures are far enough so that they cannot relate to the same object.

First signature, a \f$\texttt{size1}\times \texttt{dims}+1\f$ floating-point matrix. Each row stores the point weight followed by the point coordinates.The matrix is allowed to have a single column(weights only) if the user-defined cost matrix is used.The weights must be non-negative and have at least one non-zero value. Second signature of the same format as signature1 , though the number of rows may be different.The total weights may be different.In this case an extra "dummy" point is added to either signature1 or signature2. The weights must be non-negative and have at least one non-zero value. Used metric. User-defined size1 x size2 cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function. Optional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers.The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only(the signature matrices have a single column). You ** must** initialize \*lowerBound.If the calculated distance between mass centers is greater or equal to \*lowerBound(it means that the signatures are far enough), the function does not calculate EMD. In any case \*lowerBound is set to the calculated distance between mass centers on return. Thus, if you want to calculate both distance between mass centers and EMD, \*lowerBound should be set to 0. Resultant size1 x size2 flow matrix: flow[i,j] is a flow from i-th point of signature1 to j-th point of signature2.

Performs a marker-based image segmentation using the watershed algorithm.

Input 8-bit 3-channel image. Input/output 32-bit single-channel image (map) of markers. It should have the same size as image.

Performs initial step of meanshift segmentation of an image.

The source 8-bit, 3-channel image. The destination image of the same format and the same size as the source. The spatial window radius. The color window radius. Maximum level of the pyramid for the segmentation. Termination criteria: when to stop meanshift iterations.

Segments the image using GrabCut algorithm

Input 8-bit 3-channel image. Input/output 8-bit single-channel mask. The mask is initialized by the function when mode is set to GC_INIT_WITH_RECT. Its elements may have Cv2.GC_BGD / Cv2.GC_FGD / Cv2.GC_PR_BGD / Cv2.GC_PR_FGD ROI containing a segmented object. The pixels outside of the ROI are marked as "obvious background". The parameter is only used when mode==GC_INIT_WITH_RECT. Temporary array for the background model. Do not modify it while you are processing the same image. Temporary arrays for the foreground model. Do not modify it while you are processing the same image. Number of iterations the algorithm should make before returning the result. Note that the result can be refined with further calls with mode==GC_INIT_WITH_MASK or mode==GC_EVAL . Operation mode that could be one of GrabCutFlag value.

Calculates the distance to the closest zero pixel for each pixel of the source image.

8-bit, single-channel (binary) source image. Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src. Output 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src. Type of distance Size of the distance transform mask, see #DistanceTransformMasks. #DIST_MASK_PRECISE is not supported by this variant. In case of the #DIST_L1 or #DIST_C distance type, the parameter is forced to 3 because a 3x3 mask gives the same result as 5x5 or any larger aperture. Type of the label array to build

computes the distance transform map

8-bit, single-channel (binary) source image. Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src. Type of distance Size of the distance transform mask, see #DistanceTransformMasks. In case of the #DIST_L1 or #DIST_C distance type, the parameter is forced to 3 because a 3x3 mask gives the same result as 5x5 or any larger aperture. Type of output image. It can be MatType.CV_8U or MatType.CV_32F. Type CV_8U can be used only for the first variant of the function and distanceType == #DIST_L1.

Fills a connected component with the given color.

Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below. Starting point. New value of the repainted domain pixels. Optional output parameter set by the function to the minimum bounding rectangle of the repainted domain. Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. Operation flags. Lower bits contain a connectivity value, 4 (default) or 8, used within the function. Connectivity determines which neighbors of a pixel are considered. Using FloodFillFlags.MaskOnly will fill in the mask using the grey value 255 (white).

Fills a connected component with the given color.

Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below. (For the second function only) Operation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller. The function uses and updates the mask, so you take responsibility of initializing the mask content. Flood-filling cannot go across non-zero pixels in the mask. For example, an edge detector output can be used as a mask to stop filling at edges. It is possible to use the same mask in multiple calls to the function to make sure the filled area does not overlap. Starting point. New value of the repainted domain pixels. Optional output parameter set by the function to the minimum bounding rectangle of the repainted domain. Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component. Operation flags. Lower bits contain a connectivity value, 4 (default) or 8, used within the function. Connectivity determines which neighbors of a pixel are considered. Using FloodFillFlags.MaskOnly will fill in the mask using the grey value 255 (white).

Performs linear blending of two images: dst(i,j) = weights1(i,j)*src1(i,j) + weights2(i,j)*src2(i,j)

It has a type of CV_8UC(n) or CV_32FC(n), where n is a positive integer. It has the same type and size as src1. It has a type of CV_32FC1 and the same size with src1. It has a type of CV_32FC1 and the same size with src1. It is created if it does not have the same size and type with src1.

Converts image from one color space to another

The source image, 8-bit unsigned, 16-bit unsigned or single-precision floating-point The destination image; will have the same size and the same depth as src The color space conversion code The number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from src and the code

Converts an image from one color space to another where the source image is stored in two planes. This function only supports YUV420 to RGB conversion as of now.

8-bit image (#CV_8U) of the Y plane. image containing interleaved U/V plane. output image. Specifies the type of conversion. It can take any of the following values: - #COLOR_YUV2BGR_NV12 - #COLOR_YUV2RGB_NV12 - #COLOR_YUV2BGRA_NV12 - #COLOR_YUV2RGBA_NV12 - #COLOR_YUV2BGR_NV21 - #COLOR_YUV2RGB_NV21 - #COLOR_YUV2BGRA_NV21 - #COLOR_YUV2RGBA_NV21

main function for all demosaicing processes

input image: 8-bit unsigned or 16-bit unsigned. output image of the same size and depth as src. Color space conversion code (see the description below). number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code. The function can do the following transformations: - Demosaicing using bilinear interpolation #COLOR_BayerBG2BGR , #COLOR_BayerGB2BGR , #COLOR_BayerRG2BGR , #COLOR_BayerGR2BGR #COLOR_BayerBG2GRAY , #COLOR_BayerGB2GRAY , #COLOR_BayerRG2GRAY , #COLOR_BayerGR2GRAY - Demosaicing using Variable Number of Gradients. #COLOR_BayerBG2BGR_VNG , #COLOR_BayerGB2BGR_VNG , #COLOR_BayerRG2BGR_VNG , #COLOR_BayerGR2BGR_VNG - Edge-Aware Demosaicing. #COLOR_BayerBG2BGR_EA , #COLOR_BayerGB2BGR_EA , #COLOR_BayerRG2BGR_EA , #COLOR_BayerGR2BGR_EA - Demosaicing with alpha channel # COLOR_BayerBG2BGRA , #COLOR_BayerGB2BGRA , #COLOR_BayerRG2BGRA , #COLOR_BayerGR2BGRA

Calculates all of the moments up to the third order of a polygon or rasterized shape.

A raster image (single-channel, 8-bit or floating-point 2D array) or an array ( 1xN or Nx1 ) of 2D points ( Point or Point2f ) If it is true, then all the non-zero image pixels are treated as 1’s

Calculates all of the moments up to the third order of a polygon or rasterized shape.

A raster image (8-bit) 2D array If it is true, then all the non-zero image pixels are treated as 1’s

Calculates all of the moments up to the third order of a polygon or rasterized shape.

A raster image (floating-point) 2D array If it is true, then all the non-zero image pixels are treated as 1’s

Calculates all of the moments up to the third order of a polygon or rasterized shape.

Array of 2D points If it is true, then all the non-zero image pixels are treated as 1’s

Calculates all of the moments up to the third order of a polygon or rasterized shape.

Array of 2D points If it is true, then all the non-zero image pixels are treated as 1’s

Computes the proximity map for the raster template and the image where the template is searched for

Image where the search is running; should be 8-bit or 32-bit floating-point Searched template; must be not greater than the source image and have the same data type A map of comparison results; will be single-channel 32-bit floating-point. If image is WxH and templ is wxh then result will be (W-w+1) x (H-h+1). Specifies the comparison method Mask of searched template. It must have the same datatype and size with templ. It is not set by default.

Computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels[0, N - 1] where 0 represents the background label.ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.ccltype specifies the connected components labeling algorithm to use, currently Grana (BBDT) and Wu's (SAUF) algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details.Note that SAUF algorithm forces a row major ordering of labels while BBDT does not. This function uses parallel version of both Grana and Wu's algorithms if at least one allowed parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.

the 8-bit single-channel image to be labeled destination labeled image 8 or 4 for 8-way or 4-way connectivity respectively output image label type. Currently CV_32S and CV_16U are supported. connected components algorithm type.

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.

the image to be labeled destination labeled image 8 or 4 for 8-way or 4-way connectivity respectively The number of labels

the image to be labeled destination labeled image 8 or 4 for 8-way or 4-way connectivity respectively output image label type. Currently CV_32S and CV_16U are supported. The number of labels

the image to be labeled destination labeled rectangular array 8 or 4 for 8-way or 4-way connectivity respectively The number of labels

computes the connected components labeled image of boolean image and also produces a statistics output for each label. image with 4 or 8 way connectivity - returns N, the total number of labels[0, N - 1] where 0 represents the background label.ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.ccltype specifies the connected components labeling algorithm to use, currently Grana's (BBDT) and Wu's (SAUF) algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details.Note that SAUF algorithm forces a row major ordering of labels while BBDT does not. This function uses parallel version of both Grana and Wu's algorithms (statistics included) if at least one allowed parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.

the 8-bit single-channel image to be labeled destination labeled image statistics output for each label, including the background label, see below for available statistics.Statistics are accessed via stats(label, COLUMN) where COLUMN is one of #ConnectedComponentsTypes. The data type is CV_32S. centroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y.The data type CV_64F. 8 or 4 for 8-way or 4-way connectivity respectively output image label type. Currently CV_32S and CV_16U are supported. connected components algorithm type.

the image to be labeled destination labeled image statistics output for each label, including the background label, see below for available statistics. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of cv::ConnectedComponentsTypes floating point centroid (x,y) output for each label, including the background label 8 or 4 for 8-way or 4-way connectivity respectively

the image to be labeled 8 or 4 for 8-way or 4-way connectivity respectively

Finds contours in a binary image.

Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. Zero pixels remain 0’s, so the image is treated as binary. The function modifies the image while extracting the contours. Detected contours. Each contour is stored as a vector of points. Optional output vector, containing information about the image topology. It has as many elements as the number of contours. For each i-th contour contours[i], the members of the elements hierarchy[i] are set to 0-based indices in contours of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative. Contour retrieval mode Contour approximation method Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

Finds contours in a binary image.

Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. Zero pixels remain 0’s, so the image is treated as binary. The function modifies the image while extracting the contours. Contour retrieval mode Contour approximation method Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context. Detected contours. Each contour is stored as a vector of points.

Finds contours in a binary image.

Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. Zero pixels remain 0’s, so the image is treated as binary. The function modifies the image while extracting the contours. Contour retrieval mode Contour approximation method Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context. Detected contours. Each contour is stored as a vector of points.

Approximates contour or a curve using Douglas-Peucker algorithm

The polygon or curve to approximate. Must be 1 x N or N x 1 matrix of type CV_32SC2 or CV_32FC2. The result of the approximation; The type should match the type of the input curve Specifies the approximation accuracy. This is the maximum distance between the original curve and its approximation. The result of the approximation; The type should match the type of the input curve

Approximates contour or a curve using Douglas-Peucker algorithm

The polygon or curve to approximate. Specifies the approximation accuracy. This is the maximum distance between the original curve and its approximation. The result of the approximation; The type should match the type of the input curve The result of the approximation; The type should match the type of the input curve

Approximates contour or a curve using Douglas-Peucker algorithm

The polygon or curve to approximate. Specifies the approximation accuracy. This is the maximum distance between the original curve and its approximation. If true, the approximated curve is closed (i.e. its first and last vertices are connected), otherwise it’s not The result of the approximation; The type should match the type of the input curve

Calculates a contour perimeter or a curve length.

The input vector of 2D points, represented by CV_32SC2 or CV_32FC2 matrix. Indicates, whether the curve is closed or not.

Calculates a contour perimeter or a curve length.

The input vector of 2D points. Indicates, whether the curve is closed or not.

Calculates a contour perimeter or a curve length.

The input vector of 2D points. Indicates, whether the curve is closed or not.

Calculates the up-right bounding rectangle of a point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. Minimal up-right bounding rectangle for the specified point set.

Calculates the up-right bounding rectangle of a point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. Minimal up-right bounding rectangle for the specified point set.

Calculates the up-right bounding rectangle of a point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. Minimal up-right bounding rectangle for the specified point set.

Calculates the contour area

The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix

Calculates the contour area

The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix

Calculates the contour area

The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix

Finds the minimum area rotated rectangle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Finds the minimum area rotated rectangle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Finds the minimum area rotated rectangle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle. The function finds the four vertices of a rotated rectangle.This function is useful to draw the rectangle.In C++, instead of using this function, you can directly use RotatedRect::points method. Please visit the @ref tutorial_bounding_rotated_ellipses "tutorial on Creating Bounding rotated boxes and ellipses for contours" for more information.

The input rotated rectangle. It may be the output of The output array of four vertices of rectangles.

Finds the minimum area circle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. The output center of the circle The output radius of the circle

Finds the minimum area circle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. The output center of the circle The output radius of the circle

Finds the minimum area circle enclosing a 2D point set.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. The output center of the circle The output radius of the circle

Finds a triangle of minimum area enclosing a 2D point set and returns its area.

Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector or Mat Output vector of three 2D points defining the vertices of the triangle. The depth Triangle area

Finds a triangle of minimum area enclosing a 2D point set and returns its area.

Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector or Mat Output vector of three 2D points defining the vertices of the triangle. The depth Triangle area

Finds a triangle of minimum area enclosing a 2D point set and returns its area.

Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector or Mat Output vector of three 2D points defining the vertices of the triangle. The depth Triangle area

Compares two shapes.

First contour or grayscale image. Second contour or grayscale image. Comparison method Method-specific parameter (not supported now)

Compares two shapes.

First contour or grayscale image. Second contour or grayscale image. Comparison method Method-specific parameter (not supported now)

Computes convex hull for a set of 2D points.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix The output convex hull. It is either a vector of points that form the hull (must have the same type as the input points), or a vector of 0-based point indices of the hull points in the original array (since the set of convex hull points is a subset of the original point set). If true, the output convex hull will be oriented clockwise, otherwise it will be oriented counter-clockwise. Here, the usual screen coordinate system is assumed - the origin is at the top-left corner, x axis is oriented to the right, and y axis is oriented downwards.

Computes convex hull for a set of 2D points.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix If true, the output convex hull will be oriented clockwise, otherwise it will be oriented counter-clockwise. Here, the usual screen coordinate system is assumed - the origin is at the top-left corner, x axis is oriented to the right, and y axis is oriented downwards. The output convex hull. It is a vector of points that form the hull (must have the same type as the input points).

Computes convex hull for a set of 2D points.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix If true, the output convex hull will be oriented clockwise, otherwise it will be oriented counter-clockwise. Here, the usual screen coordinate system is assumed - the origin is at the top-left corner, x axis is oriented to the right, and y axis is oriented downwards. The output convex hull. It is a vector of 0-based point indices of the hull points in the original array (since the set of convex hull points is a subset of the original point set).

Computes convex hull for a set of 2D points.

The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix If true, the output convex hull will be oriented clockwise, otherwise it will be oriented counter-clockwise. Here, the usual screen coordinate system is assumed - the origin is at the top-left corner, x axis is oriented to the right, and y axis is oriented downwards. The output convex hull. It is a vector of 0-based point indices of the hull points in the original array (since the set of convex hull points is a subset of the original point set).

Computes the contour convexity defects

Input contour. Convex hull obtained using convexHull() that should contain indices of the contour points that make the hull. The output vector of convexity defects. Each convexity defect is represented as 4-element integer vector (a.k.a. cv::Vec4i): (start_index, end_index, farthest_pt_index, fixpt_depth), where indices are 0-based indices in the original contour of the convexity defect beginning, end and the farthest point, and fixpt_depth is fixed-point approximation (with 8 fractional bits) of the distance between the farthest contour point and the hull. That is, to get the floating-point value of the depth will be fixpt_depth/256.0.

Computes the contour convexity defects

returns true if the contour is convex. Does not support contours with self-intersection

Input vector of 2D points

returns true if the contour is convex. Does not support contours with self-intersection

Input vector of 2D points

returns true if the contour is convex. D oes not support contours with self-intersection

Input vector of 2D points

finds intersection of two convex polygons

Fits ellipse to the set of 2D points.

Input 2D point set

Fits ellipse to the set of 2D points.

Input 2D point set

Fits ellipse to the set of 2D points.

Input 2D point set

Fits an ellipse around a set of 2D points. The function calculates the ellipse that fits a set of 2D points. It returns the rotated rectangle in which the ellipse is inscribed. The Approximate Mean Square(AMS) proposed by @cite Taubin1991 is used.

Input 2D point set

Fits an ellipse around a set of 2D points. The function calculates the ellipse that fits a set of 2D points. It returns the rotated rectangle in which the ellipse is inscribed. The Direct least square(Direct) method by @cite Fitzgibbon1999 is used.

Input 2D point set

Fits line to the set of 2D points using M-estimator algorithm

Input vector of 2D or 3D points Output line parameters. In case of 2D fitting, it should be a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line. In case of 3D fitting, it should be a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0), where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on the line. Distance used by the M-estimator Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value is chosen. Sufficient accuracy for the radius (distance between the coordinate origin and the line). Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.

Fits line to the set of 2D points using M-estimator algorithm

Input vector of 2D or 3D points Distance used by the M-estimator Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value is chosen. Sufficient accuracy for the radius (distance between the coordinate origin and the line). Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps. Output line parameters.

Fits line to the set of 2D points using M-estimator algorithm

Fits line to the set of 3D points using M-estimator algorithm

Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary

Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary.

Input contour. Point tested against the contour. If true, the function estimates the signed distance from the point to the nearest contour edge. Otherwise, the function only checks if the point is inside a contour or not. Positive (inside), negative (outside), or zero (on an edge) value.

Finds out if there is any intersection between two rotated rectangles. If there is then the vertices of the interesecting region are returned as well. Below are some examples of intersection configurations. The hatched pattern indicates the intersecting region and the red vertices are returned by the function.

First rectangle Second rectangle The output array of the verticies of the intersecting region. It returns at most 8 vertices. Stored as std::vector<cv::Point2f> or cv::Mat as Mx1 of type CV_32FC2.

First rectangle Second rectangle The output array of the verticies of the intersecting region. It returns at most 8 vertices.

Applies a GNU Octave/MATLAB equivalent colormap on a given image.

The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. The result is the colormapped source image. Note: Mat::create is called on dst. colormap The colormap to apply

Applies a user colormap on a given image.

The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. The result is the colormapped source image. Note: Mat::create is called on dst. The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256

Draws a line segment connecting two points

The image. First point's x-coordinate of the line segment. First point's y-coordinate of the line segment. Second point's x-coordinate of the line segment. Second point's y-coordinate of the line segment. Line color. Line thickness. [By default this is 1] Type of the line. [By default this is LineType.Link8] Number of fractional bits in the point coordinates. [By default this is 0]

Draws a line segment connecting two points

The image. First point of the line segment. Second point of the line segment. Line color. Line thickness. [By default this is 1] Type of the line. [By default this is LineType.Link8] Number of fractional bits in the point coordinates. [By default this is 0]

Draws a arrow segment pointing from the first point to the second one. The function arrowedLine draws an arrow between pt1 and pt2 points in the image. See also cv::line.

Image. The point the arrow starts from. The point the arrow points to. Line color. Line thickness. Type of the line, see cv::LineTypes Number of fractional bits in the point coordinates. The length of the arrow tip in relation to the arrow length

Draws simple, thick or filled rectangle

Image. One of the rectangle vertices. Opposite rectangle vertex. Line color (RGB) or brightness (grayscale image). Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1] Type of the line, see cvLine description. [By default this is LineType.Link8] Number of fractional bits in the point coordinates. [By default this is 0]

Draws simple, thick or filled rectangle

Image. Rectangle. Line color (RGB) or brightness (grayscale image). Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1] Type of the line, see cvLine description. [By default this is LineType.Link8] Number of fractional bits in the point coordinates. [By default this is 0]

Draws simple, thick or filled rectangle

Draws a circle

Image where the circle is drawn. X-coordinate of the center of the circle. Y-coordinate of the center of the circle. Radius of the circle. Circle color. Thickness of the circle outline if positive, otherwise indicates that a filled circle has to be drawn. [By default this is 1] Type of the circle boundary. [By default this is LineType.Link8] Number of fractional bits in the center coordinates and radius value. [By default this is 0]

Draws a circle

Image where the circle is drawn. Center of the circle. Radius of the circle. Circle color. Thickness of the circle outline if positive, otherwise indicates that a filled circle has to be drawn. [By default this is 1] Type of the circle boundary. [By default this is LineType.Link8] Number of fractional bits in the center coordinates and radius value. [By default this is 0]

Draws simple or thick elliptic arc or fills ellipse sector

Image. Center of the ellipse. Length of the ellipse axes. Rotation angle. Starting angle of the elliptic arc. Ending angle of the elliptic arc. Ellipse color. Thickness of the ellipse arc. [By default this is 1] Type of the ellipse boundary. [By default this is LineType.Link8] Number of fractional bits in the center coordinates and axes' values. [By default this is 0]

Draws simple or thick elliptic arc or fills ellipse sector

Image. The enclosing box of the ellipse drawn Ellipse color. Thickness of the ellipse boundary. [By default this is 1] Type of the ellipse boundary. [By default this is LineType.Link8]

Draws a marker on a predefined position in an image. The function cv::drawMarker draws a marker on a given position in the image.For the moment several marker types are supported, see #MarkerTypes for more information.

Image. The point where the crosshair is positioned. Line color. The specific type of marker you want to use. The length of the marker axis [default = 20 pixels] Line thickness. Type of the line.

Fills a convex polygon.

Image The polygon vertices Polygon color Type of the polygon boundaries The number of fractional bits in the vertex coordinates

Fills a convex polygon.

Image The polygon vertices Polygon color Type of the polygon boundaries The number of fractional bits in the vertex coordinates

Fills the area bounded by one or more polygons

Image Array of polygons, each represented as an array of points Polygon color Type of the polygon boundaries The number of fractional bits in the vertex coordinates

Fills the area bounded by one or more polygons

Image Array of polygons, each represented as an array of points Polygon color Type of the polygon boundaries The number of fractional bits in the vertex coordinates

draws one or more polygonal curves

draws contours in the image

Destination image. All the input contours. Each contour is stored as a point vector. Parameter indicating a contour to draw. If it is negative, all the contours are drawn. Color of the contours. Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), the contour interiors are drawn. Line connectivity. Optional information about hierarchy. It is only needed if you want to draw only some of the contours Maximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available. Optional contour shift parameter. Shift all the drawn contours by the specified offset = (dx, dy)

draws contours in the image

Clips the line against the image rectangle

The image size The first line point The second line point

Clips the line against the image rectangle

sThe image rectangle The first line point The second line point

Approximates an elliptic arc with a polyline. The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by cv::ellipse.

Center of the arc. Half of the size of the ellipse main axes. See the ellipse for details. Rotation angle of the ellipse in degrees. See the ellipse for details. Starting angle of the elliptic arc in degrees. Ending angle of the elliptic arc in degrees. Angle between the subsequent polyline vertices. It defines the approximation Output vector of polyline vertices.

Approximates an elliptic arc with a polyline. The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by cv::ellipse.

renders text string in the image

Image. Text string to be drawn. Bottom-left corner of the text string in the image. Font type, see #HersheyFonts. Font scale factor that is multiplied by the font-specific base size. Text color. Thickness of the lines used to draw a text. Line type. See #LineTypes When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner.

returns bounding box of the text string

Input text string. Font to use, see #HersheyFonts. Font scale factor that is multiplied by the font-specific base size. Thickness of lines used to render the text. See #putText for details. baseLine y-coordinate of the baseline relative to the bottom-most text The size of a box that contains the specified text.

Calculates the font-specific size to use to achieve a given height in pixels.

Font to use, see cv::HersheyFonts. Pixel height to compute the fontScale for Thickness of lines used to render the text.See putText for details. The fontSize to use for cv::putText

Groups the object candidate rectangles.

Input/output vector of rectangles. Output vector includes retained and grouped rectangles. Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it.

Groups the object candidate rectangles.

Input/output vector of rectangles. Output vector includes retained and grouped rectangles. Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it. Relative difference between sides of the rectangles to merge them into a group.

Groups the object candidate rectangles.

Restores the selected region in an image using the region neighborhood.

Input 8-bit, 16-bit unsigned or 32-bit float 1-channel or 8-bit 3-channel image. Inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted. Output image with the same size and type as src. Radius of a circular neighborhood of each point inpainted that is considered by the algorithm. Inpainting method that could be cv::INPAINT_NS or cv::INPAINT_TELEA

Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations. Noise expected to be a gaussian white noise

Input 8-bit 1-channel, 2-channel or 3-channel image. Output image with the same size and type as src . Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels

Modification of fastNlMeansDenoising function for colored images

Input 8-bit 3-channel image. Output image with the same size and type as src. Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise The same as h but for color components. For most images value equals 10 will be enought to remove colored noise and do not distort colors Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels

Modification of fastNlMeansDenoising function for images sequence where consequtive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces.

Input 8-bit 1-channel, 2-channel or 3-channel images sequence. All images should have the same type and size. Output image with the same size and type as srcImgs images. Target image to denoise index in srcImgs sequence Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image. Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels

Modification of fastNlMeansDenoisingMulti function for colored images sequences

Input 8-bit 3-channel images sequence. All images should have the same type and size. Output image with the same size and type as srcImgs images. Target image to denoise index in srcImgs sequence Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image. Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise. The same as h but for color components. Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels

Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

This array should contain one or more noised versions of the image that is to be restored. Here the denoised image will be stored. There is no need to do pre-allocation of storage space, as it will be automatically allocated, if necessary. Corresponds to \f$\lambda\f$ in the formulas above. As it is enlarged, the smooth (blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, the result will be more blur but more sever outliers will be removed. Number of iterations that the algorithm will run. Of course, as more iterations as better, but it is hard to quantitatively refine this statement, so just use the default and increase it if the results are poor.

Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications @cite CL12 .

Input 8-bit 3-channel image. Output 8-bit 1-channel image. Output 8-bit 3-channel image.

Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content @cite PM03 .

Input 8-bit 3-channel image. Input 8-bit 3-channel image. Input 8-bit 1 or 3-channel image. Point in dst image where object is placed. Output image with the same size and type as dst. Cloning method

Given an original color image, two differently colored versions of this image can be mixed seamlessly. Multiplication factor is between 0.5 to 2.5.

Input 8-bit 3-channel image. Input 8-bit 1 or 3-channel image. Output image with the same size and type as src. R-channel multiply factor. G-channel multiply factor. B-channel multiply factor.

Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

Input 8-bit 3-channel image. Input 8-bit 1 or 3-channel image. Output image with the same size and type as src. Value ranges between 0-2. Value ranges between 0-2. This is useful to highlight under-exposed foreground objects or to reduce specular reflections.

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Input 8-bit 3-channel image. Input 8-bit 1 or 3-channel image. Output image with the same size and type as src. Range from 0 to 100. Value > 100. The size of the Sobel kernel to be used.

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications @cite EM11 .

Input 8-bit 3-channel image. Output 8-bit 3-channel image. Edge preserving filters Range between 0 to 200. Range between 0 to 1.

This filter enhances the details of a particular image.

Input 8-bit 3-channel image. Output image with the same size and type as src. Range between 0 to 200. Range between 0 to 1.

Pencil-like non-photorealistic line drawing

Input 8-bit 3-channel image. Output 8-bit 1-channel image. Output image with the same size and type as src. Range between 0 to 200. Range between 0 to 1. Range between 0 to 0.1.

Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

Input 8-bit 3-channel image. Output image with the same size and type as src. Range between 0 to 200. Range between 0 to 1.

Create Bilateral TV-L1 Super Resolution.

Finds an object center, size, and orientation.

Back projection of the object histogram. Initial search window. Stop criteria for the underlying MeanShift() .

Finds an object on a back projection image.

Back projection of the object histogram. Initial search window. Stop criteria for the iterative search algorithm. Number of iterations CAMSHIFT took to converge.

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

8-bit input image. output pyramid. window size of optical flow algorithm. Must be not less than winSize argument of calcOpticalFlowPyrLK(). It is needed to calculate required padding for pyramid levels. 0-based maximal pyramid level number. set to precompute gradients for the every pyramid level. If pyramid is constructed without the gradients then calcOpticalFlowPyrLK() will calculate them internally. the border mode for pyramid layers. the border mode for gradients. put ROI of input image into the pyramid if possible. You can pass false to force data copying. number of levels in constructed pyramid. Can be less than maxLevel.

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

computes sparse optical flow using multi-scale Lucas-Kanade algorithm

Computes a dense optical flow using the Gunnar Farneback's algorithm.

first 8-bit single-channel input image. second input image of the same size and the same type as prev. computed flow image that has the same size as prev and type CV_32FC2. parameter, specifying the image scale (<1) to build pyramids for each image; pyrScale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous one. number of pyramid layers including the initial image; levels=1 means that no extra layers are created and only the original images are used. averaging window size; larger values increase the algorithm robustness to image noise and give more chances for fast motion detection, but yield more blurred motion field. number of iterations the algorithm does at each pyramid level. size of the pixel neighborhood used to find polynomial expansion in each pixel; larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field, typically poly_n =5 or 7. standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion; for polyN=5, you can set polySigma=1.1, for polyN=7, a good value would be polySigma=1.5. operation flags that can be a combination of OPTFLOW_USE_INITIAL_FLOW and/or OPTFLOW_FARNEBACK_GAUSSIAN

Computes the Enhanced Correlation Coefficient value between two images @cite EP08 .

single-channel template image; CV_8U or CV_32F array. single-channel input image to be warped to provide an image similar to templateImage, same type as templateImage. An optional mask to indicate valid values of inputImage.

Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08 .

single-channel template image; CV_8U or CV_32F array. single-channel input image which should be warped with the final warpMatrix in order to provide an image similar to templateImage, same type as templateImage. floating-point \f$2\times 3\f$ or \f$3\times 3\f$ mapping matrix (warp). parameter, specifying the type of motion parameter, specifying the termination criteria of the ECC algorithm; criteria.epsilon defines the threshold of the increment in the correlation coefficient between two iterations(a negative criteria.epsilon makes criteria.maxcount the only termination criterion). Default values are shown in the declaration above. An optional mask to indicate valid values of inputImage. An optional value indicating size of gaussian blur filter; (DEFAULT: 5)

Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08 .

A class which has a pointer of OpenCV structure

Data pointer

Default constructor

Native pointer of OpenCV structure

DisposableObject + ICvPtrHolder

Data pointer

Default constructor

Constructor

releases unmanaged resources

Native pointer of OpenCV structure

Represents a class which manages its own memory.

Gets or sets a handle which allocates using cvSetData.

Gets a value indicating whether this instance has been disposed.

Gets or sets a value indicating whether you permit disposing this instance.

Gets or sets a memory address allocated by AllocMemory.

Gets or sets the byte length of the allocated memory

Default constructor

Constructor

true if you permit disposing this class by GC

Releases the resources

If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed. If false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.

Destructor

Releases managed resources

Releases unmanaged resources

Pins the object to be allocated by cvSetData.

Allocates the specified size of memory.

Notifies the allocated size of memory.

If this object is disposed, then ObjectDisposedException is thrown.

Represents a OpenCV-based class which has a native pointer.

Unmanaged OpenCV data pointer

A MemoryManager over an OpenCvSharpMat

The pointer is assumed to be fully unmanaged, or externally pinned - no attempt will be made to pin this data

Create a new UnmanagedMemoryManager instance at the given pointer and size

It is assumed that the span provided is already unmanaged or externally pinned

Provides access to a pointer that represents the data (note: no actual pin occurs)

Has no effect

Releases all resources associated with this object

The default exception to be thrown by OpenCV

The numeric code for error status

The source file name where error is encountered

A description of the error

The source file name where error is encountered

The line number in the source where error is encountered

Constructor

The numeric code for error status The source file name where error is encountered A description of the error The source file name where error is encountered The line number in the source where error is encountered

The exception that is thrown by OpenCvSharp.

Template class for smart reference-counting pointers

Constructor

Returns Ptr<T>.get() pointer

Used for managing the resources of OpenCVSharp, like Mat, MatExpr, etc.

Trace the object obj, and return it

Trace an array of objects , and return them

Create a new Mat instance, and trace it

size matType scalar

Create a new UMat instance, and trace it

size matType scalar

Dispose all traced objects

Whether native methods for P/Invoke raises an exception

P/Invoke methods of OpenCV 2.x C++ interface

Is tried P/Invoke once

Static constructor

Load DLL files dynamically using Win32 LoadLibrary

Checks whether PInvoke functions can be called

Returns whether the OS is Windows or not

Returns whether the OS is *nix or not

Returns whether the runtime is Mono or not

Returns whether the architecture is Wasm or not

Custom error handler to be thrown by OpenCV

Custom error handler to ignore all OpenCV errors

Default error handler

C++ std::string

Releases unmanaged resources

string.size()

Converts std::string to managed string

Win32API Wrapper

Handles loading embedded dlls into memory, based on http://stackoverflow.com/questions/666799/embedding-unmanaged-dll-into-a-managed-c-sharp-dll.

This code is based on https://github.com/charlesw/tesseract

The default base directory name to copy the assemblies too.

Map processor

Used as a sanity check for the returned processor architecture to double check the returned value.

Additional user-defined DLL paths

constructor

Determine if the OS is Windows

Determine if the runtime is .NET Core

Get's the current process architecture while keeping track of any assumptions or possible errors.

Determines if the dynamic link library file name requires a suffix and adds it if necessary.

Given the processor architecture, returns the name of the platform.

Releases unmanaged resources

Class to get address of specified jagged array

Releases unmanaged resources

enumerable as T[] ?? enumerable.ToArray()

Checks whether PInvoke functions can be called

DllImportの際にDllNotFoundExceptionかBadImageFormatExceptionが発生した際に呼び出されるメソッド。エラーメッセージを表示して解決策をユーザに示す。

Provides information for the platform which the user is using

OS type

Runtime type

Readonly rectangular array (T[,])

Constructor

Indexer

Gets the total number of elements in all the dimensions of the System.Array.

Gets a 32-bit integer that represents the number of elements in the specified dimension of the System.Array.

Returns internal buffer

Original GCHandle that implement IDisposable

Constructor

Represents std::vector

vector.size()

Convert std::vector<T> to managed array T[]

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

structure that has two float members (ex. CvLineSegmentPolar, CvPoint2D32f, PointF)

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

structure that has two float members (ex. CvLineSegmentPolar, CvPoint2D32f, PointF)

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

structure that has four int members (ex. CvLineSegmentPoint, CvRect)

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

structure that has four int members (ex. CvLineSegmentPoint, CvRect)

Constructor

Releases unmanaged resources

vector.size()

&vector[0]

Converts std::vector to managed array

structure that has four int members (ex. CvLineSegmentPoint, CvRect)

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

Converts std::vector to managed array

Constructor

Releases unmanaged resources

vector.size()

vector[i].size()

Converts std::vector to managed array

aruco module

Basic marker detection

input image indicates the type of markers that will be searched vector of detected marker corners. For each marker, its four corners are provided. For N detected markers, the dimensions of this array is Nx4.The order of the corners is clockwise. vector of identifiers of the detected markers. The identifier is of type int. For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array. marker detection parameters contains the imgPoints of those squares whose inner code has not a correct codification.Useful for debugging purposes.

Pose estimation for single markers

corners vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f>> ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise. the length of the markers' side. The returning translation vectors will be in the same unit.Normally, unit is meters. input 3x3 floating-point camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements array of output rotation vectors (@sa Rodrigues) (e.g. std::vector<cv::Vec3d>). Each element in rvecs corresponds to the specific marker in imgPoints. array of output translation vectors (e.g. std::vector<cv::Vec3d>). Each element in tvecs corresponds to the specific marker in imgPoints. array of object points of all the marker corners

Draw detected markers in image

input/output image. It must have 1 or 3 channels. The number of channels is not altered. positions of marker corners on input image. For N detected markers, the dimensions of this array should be Nx4.The order of the corners should be clockwise. vector of identifiers for markers in markersCorners. Optional, if not provided, ids are not painted.

Draw detected markers in image

Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME

Reads a new dictionary from FileNode.

Dictionary format is YAML see sample below


            nmarkers: 35
            markersize: 6
            maxCorrectionBits: 5
            marker_0: "101011111011111001001001101100000000"
            ...
            marker_34: "011111010000111011111110110101100101"

The path of the dictionary file Instance of a Dictionary

Detect ChArUco Diamond markers.

input image necessary for corner subpixel. list of detected marker corners from detectMarkers function. list of marker ids in markerCorners. rate between square and marker length: squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary. output list of detected diamond corners (4 corners per diamond). The order is the same than in marker corners: top left, top right, bottom right and bottom left. Similar format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f>>). ids of the diamonds in diamondCorners. The id of each diamond is in fact of type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the diamond. Optional camera calibration matrix. Optional camera distortion coefficients.

Draw a set of detected ChArUco Diamond markers.

input/output image. It must have 1 or 3 channels. The number of channels is not altered. positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f>>). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise. vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>). Optional, if not provided, ids are not painted.

Draw a set of detected ChArUco Diamond markers.

Parameters for the detectMarker process

minimum window size for adaptive thresholding before finding contours (default 3).

adaptiveThreshWinSizeMax: maximum window size for adaptive thresholding before finding contours(default 23).

increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax during the thresholding(default 10).

constant for adaptive thresholding before finding contours (default 7)

determine minimum perimeter for marker contour to be detected. This is defined as a rate respect to the maximum dimension of the input image(default 0.03).

determine maximum perimeter for marker contour to be detected. This is defined as a rate respect to the maximum dimension of the input image(default 4.0).

minimum accuracy during the polygonal approximation process to determine which contours are squares.

minimum distance between corners for detected markers relative to its perimeter(default 0.05)

minimum distance of any corner to the image border for detected markers (in pixels) (default 3)

minimum mean distance between two marker corners to be considered similar, so that the smaller one is removed.The rate is relative to the smaller perimeter of the two markers(default 0.05).

corner refinement method. (CORNER_REFINE_NONE, no refinement. CORNER_REFINE_SUBPIX, do subpixel refinement. CORNER_REFINE_CONTOUR use contour-Points)

window size for the corner refinement process (in pixels) (default 5).

maximum number of iterations for stop criteria of the corner refinement process(default 30).

minimum error for the stop criteria of the corner refinement process(default: 0.1)

number of bits of the marker border, i.e. marker border width (default 1).

number of bits (per dimension) for each cell of the marker when removing the perspective(default 8).

width of the margin of pixels on each cell not considered for the determination of the cell bit.Represents the rate respect to the total size of the cell, i.e. perspectiveRemovePixelPerCell (default 0.13)

maximum number of accepted erroneous bits in the border (i.e. number of allowed white bits in the border). Represented as a rate respect to the total number of bits per marker(default 0.35).

minimun standard deviation in pixels values during the decodification step to apply Otsu thresholding(otherwise, all the bits are set to 0 or 1 depending on mean higher than 128 or not) (default 5.0)

errorCorrectionRate error correction rate respect to the maximun error correction capability for each dictionary. (default 0.6).

Detection of quads can be done on a lower-resolution image, improving speed at a cost of pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still done at full resolution.

What Gaussian blur should be applied to the segmented image (used for quad detection?) Parameter is the standard deviation in pixels. Very noisy images benefit from non-zero values (e.g. 0.8).

reject quads containing too few pixels.

how many corner candidates to consider when segmenting a group of pixels into a quad.

Reject quads where pairs of edges have angles that are close to straight or close to 180 degrees. Zero means that no quads are rejected. (In radians).

When fitting lines to the contours, what is the maximum mean squared error allowed? This is useful in rejecting contours that are far from being quad shaped; rejecting these quads "early" saves expensive decoding processing.

When we build our model of black & white pixels, we add an extra check that the white model must be (overall) brighter than the black model. How much brighter? (in pixel values, [0,255]).

should the thresholded image be deglitched? Only useful for very noisy images

to check if there is a white marker. In order to generate a "white" marker just invert a normal marker by using a tilde, ~markerImage. (default false)

enable the new and faster Aruco detection strategy. Proposed in the paper: * Romero-Ramirez et al: Speeded up detection of squared fiducial markers (2018) * https://www.researchgate.net/publication/325787310_Speeded_Up_Detection_of_Squared_Fiducial_Markers

minimum side length of a marker in the canonical image. Latter is the binarized image in which contours are searched.

range [0,1], eq (2) from paper. The parameter tau_i has a direct influence on the processing speed.

Constructor

Dictionary/Set of markers. It contains the inner codification

Releases unmanaged resources

Marker code information

Number of bits per dimension.

Maximum number of bits that can be corrected.

Given a matrix of bits. Returns whether if marker is identified or not. It returns by reference the correct id (if any) and the correct rotation

Returns the distance of the input bits to the specific id. If allRotations is true, the four possible bits rotation are considered

Generate a canonical marker image

Transform matrix of bits to list of bytes in the 4 rotations

Transform list of bytes to matrix of bits

corner refinement method

Tag and corners detection based on the ArUco approach.

ArUco approach and refine the corners locations using corner subpixel accuracy.

ArUco approach and refine the corners locations using the contour-points line fitting.

Tag and corners detection based on the AprilTag 2 approach

PredefinedDictionaryName

Background Subtractor module. Takes a series of images and returns a sequence of mask (8UC1) images of the same size, where 255 indicates Foreground and 0 represents Background.

cv::Ptr<T>

Creates a GMG Background Subtractor

number of frames used to initialize the background models. Threshold value, above which it is marked foreground, else background.

Releases managed resources

Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm

cv::Ptr<T>

Creates mixture-of-gaussian background subtractor

Length of the history. Number of Gaussian mixtures. Background ratio. Noise strength (standard deviation of the brightness or each color channel). 0 means some automatic value.

Releases managed resources

Different flags for cvCalibrateCamera2 and cvStereoCalibrate

The flag allows the function to optimize some or all of the intrinsic parameters, depending on the other flags, but the initial values are provided by the user

fyk is optimized, but the ratio fxk/fyk is fixed.

The principal points are fixed during the optimization.

Tangential distortion coefficients are set to zeros and do not change during the optimization.

fxk and fyk are fixed.

The 0-th distortion coefficients (k1) are fixed

The 1-th distortion coefficients (k2) are fixed

The 4-th distortion coefficients (k3) are fixed

Do not change the corresponding radial distortion coefficient during the optimization. If CV_CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used, otherwise it is set to 0.

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 will compute only 5 distortion coefficients.

If it is set, camera_matrix1,2, as well as dist_coeffs1,2 are fixed, so that only extrinsic parameters are optimized.

Enforces fx0=fx1 and fy0=fy1. CV_CALIB_ZERO_TANGENT_DIST - Tangential distortion coefficients for each camera are set to zeros and fixed there.

for stereo rectification

Various operation flags for cvFindChessboardCorners

Use adaptive thresholding to convert the image to black-n-white, rather than a fixed threshold level (computed from the average image brightness).

Normalize the image using cvNormalizeHist before applying fixed or adaptive thresholding.

Use additional criteria (like contour area, perimeter, square-like shape) to filter out false quads that are extracted at the contour retrieval stage.

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.

Run an exhaustive search to improve detection rate.

Up sample input image to improve sub-pixel accuracy due to aliasing effects. This should be used if an accurate camera calibration is required.

Method for computing the essential matrix

for LMedS algorithm.

for RANSAC algorithm.

Method for solving a PnP problem:

uses symmetric pattern of circles.

uses asymmetric pattern of circles.

uses a special algorithm for grid detection. It is more robust to perspective distortions but much more sensitive to background clutter.

Method for computing the fundamental matrix

for 7-point algorithm. N == 7

for 8-point algorithm. N >= 8 [CV_FM_8POINT]

for LMedS algorithm. N > 8

for RANSAC algorithm. N > 8

method One of the implemented Hand-Eye calibration method

A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration @cite Tsai89

Robot Sensor Calibration: Solving AX = XB on the Euclidean Group @cite Park94

Hand-eye Calibration @cite Horaud95

On-line Hand-Eye Calibration @cite Andreff99

Hand-Eye Calibration Using Dual Quaternions @cite Daniilidis98

The method used to computed homography matrix

Regular method using all the point pairs

Least-Median robust method

RANSAC-based robust method

RHO algorithm

USAC algorithm, default settings

USAC, parallel version

USAC, fundamental matrix 8 points

USAC, fast settings

USAC, accurate settings

USAC, sorted points, runs PROSAC

USAC, runs MAGSAC++

cv::initWideAngleProjMap flags

One of the implemented Robot-World/Hand-Eye calibration method

Solving the robot-world/hand-eye calibration problem using the kronecker product @cite Shah2013SolvingTR

Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product @cite Li2010SimultaneousRA

type of the robust estimation algorithm

least-median of squares algorithm

RANSAC algorithm

RHO algorithm

USAC algorithm, default settings

USAC, parallel version

USAC, fundamental matrix 8 points

USAC, fast settings

USAC, accurate settings

USAC, sorted points, runs PROSAC

USAC, runs MAGSAC++

Method for solving a PnP problem:

Iterative method is based on Levenberg-Marquardt optimization. In this case the 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 projectPoints() ) objectPoints .

Method has been introduced by F.Moreno-Noguer, V.Lepetit and P.Fua in the paper “EPnP: Efficient Perspective-n-Point Camera Pose Estimation”.

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”. In this case the function requires exactly four object and image points.

Joel A. Hesch and Stergios I. Roumeliotis. "A Direct Least-Squares (DLS) Method for PnP"

A.Penate-Sanchez, J.Andrade-Cetto, F.Moreno-Noguer. "Exhaustive Linearization for Robust Camera Pose and Focal Length Estimation"

The operation flags for cvStereoRectify

Default value (=0). the function can shift one of the image in horizontal or vertical direction (depending on the orientation of epipolar lines) in order to maximise the useful image area.

the function makes the principal points of each camera have the same pixel coordinates in the rectified views.

Semi-Global Stereo Matching

constructor

Releases managed resources

The base class for stereo correspondence algorithms.

constructor

Computes disparity map for the specified stereo pair

Left 8-bit single-channel image. Right image of the same size and the same type as the left one. Output disparity map. It has the same size as the input images. Some algorithms, like StereoBM or StereoSGBM compute 16-bit fixed-point disparity map(where each disparity value has 4 fractional bits), whereas other algorithms output 32 - bit floating - point disparity map.

Semi-Global Stereo Matching

constructor

Releases managed resources

Truncation value for the prefiltered image pixels. The algorithm first computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval. The result values are passed to the Birchfield-Tomasi pixel cost function.

Margin in percentage by which the best (minimum) computed cost function value should "win" the second best value to consider the found match correct. Normally, a value within the 5-15 range is good enough.

The first parameter controlling the disparity smoothness. See P2 description.

The second parameter controlling the disparity smoothness. The larger the values are, the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1 between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor pixels. The algorithm requires P2 \> P1 . See stereo_match.cpp sample where some reasonably good P1 and P2 values are shown (like 8\*number_of_image_channels\*SADWindowSize\*SADWindowSize and 32\*number_of_image_channels\*SADWindowSize\*SADWindowSize , respectively).

Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and huge for HD-size pictures. By default, it is set to false .

Base class for high-level OpenCV algorithms

Stores algorithm parameters in a file storage

Reads algorithm parameters from a file storage

Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

Saves the algorithm to a file. In order to make this method work, the derived class must implement Algorithm::write(FileStorage fs).

Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.

Error Handler

cv::AccessFlag

cv::Algorithm parameter type

Type of the border to create around the copied source image rectangle

https://github.com/opencv/opencv/blob/fc1a15626226609babd128e043cf7c4e32f567ca/modules/core/include/opencv2/core/base.hpp#L268

Border is filled with the fixed value, passed as last parameter of the function. `iiiiii|abcdefgh|iiiiiii` with some specified `i`

The pixels from the top and bottom rows, the left-most and right-most columns are replicated to fill the border. `aaaaaa|abcdefgh|hhhhhhh`

`fedcba|abcdefgh|hgfedcb`

`cdefgh|abcdefgh|abcdefg`

`gfedcb|abcdefgh|gfedcba`

`uvwxyz|absdefgh|ijklmno`

same as BORDER_REFLECT_101

do not look outside of ROI

The flag specifying the relation between the elements to be checked

src1(I) "equal to" src2(I)

src1(I) "greater than" src2(I)

src1(I) "greater or equal" src2(I)

src1(I) "less than" src2(I)

src1(I) "less or equal" src2(I)

src1(I) "not equal to" src2(I)

Operation flags for Covariation

scale * [vects[0]-avg,vects[1]-avg,...]^T * [vects[0]-avg,vects[1]-avg,...] that is, the covariation matrix is count×count. Such an unusual covariation matrix is used for fast PCA of a set of very large vectors (see, for example, Eigen Faces technique for face recognition). Eigenvalues of this "scrambled" matrix will match to the eigenvalues of the true covariation matrix and the "true" eigenvectors can be easily calculated from the eigenvectors of the "scrambled" covariation matrix.

scale * [vects[0]-avg,vects[1]-avg,...]*[vects[0]-avg,vects[1]-avg,...]^T that is, cov_mat will be a usual covariation matrix with the same linear size as the total number of elements in every input vector. One and only one of CV_COVAR_SCRAMBLED and CV_COVAR_NORMAL must be specified

If the flag is specified, the function does not calculate avg from the input vectors, but, instead, uses the passed avg vector. This is useful if avg has been already calculated somehow, or if the covariation matrix is calculated by parts - in this case, avg is not a mean vector of the input sub-set of vectors, but rather the mean vector of the whole set.

If the flag is specified, the covariation matrix is scaled by the number of input vectors.

Means that all the input vectors are stored as rows of a single matrix, vects[0].count is ignored in this case, and avg should be a single-row vector of an appropriate size.

Means that all the input vectors are stored as columns of a single matrix, vects[0].count is ignored in this case, and avg should be a single-column vector of an appropriate size.

Type of termination criteria

the maximum number of iterations or elements to compute

the desired accuracy or change in parameters at which the iterative algorithm stops

Transformation flags for cv::dct

Do inverse 1D or 2D transform. (Forward and Inverse are mutually exclusive, of course.)

Do forward or inverse transform of every individual row of the input matrix. This flag allows user to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself), to do 3D and higher-dimensional transforms etc. [CV_DXT_ROWS]

Inversion methods

Gaussian elimination with the optimal pivot element chosen.

singular value decomposition (SVD) method; the system can be over-defined and/or the matrix src1 can be singular

eigenvalue decomposition; the matrix src1 must be symmetrical

Cholesky \f$LL^T\f$ factorization; the matrix src1 must be symmetrical and positively defined

QR factorization; the system can be over-defined and/or the matrix src1 can be singular

while all the previous flags are mutually exclusive, this flag can be used together with any of the previous

Transformation flags for cvDFT

Do inverse 1D or 2D transform. The result is not scaled. (Forward and Inverse are mutually exclusive, of course.)

Scale the result: divide it by the number of array elements. Usually, it is combined with Inverse.

performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry (*CCS*, see the function description below for details), and such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default; however, you may wish to get a full complex array (for simpler spectrum analysis, and so on) - pass the flag to enable the function to produce a full-size complex output array.

performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size, however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag), the output is a real array; while the function itself does not check whether the input is symmetrical or not, you can pass the flag and then the function will assume the symmetry and produce the real output array (note that when the input is packed into a real array and inverse transformation is executed, the function treats the input as a packed complex-conjugate symmetrical array, and the output will also be a real array).

Distribution type for cvRandArr, etc.

Uniform distribution

Normal or Gaussian distribution

Error status codes

everithing is ok [CV_StsOk]

pseudo error for back trace [CV_StsBackTrace]

unknown /unspecified error [CV_StsError]

internal error (bad state) [CV_StsInternal]

insufficient memory [CV_StsNoMem]

function arg/param is bad [CV_StsBadArg]

unsupported function [CV_StsBadFunc]

iter. didn't converge [CV_StsNoConv]

tracing [CV_StsAutoTrace]

image header is NULL [CV_HeaderIsNull]

image size is invalid [CV_BadImageSize]

offset is invalid [CV_BadOffset]

[CV_BadOffset]

[CV_BadStep]

[CV_BadModelOrChSeq]

[CV_BadNumChannels]

[CV_BadNumChannel1U]

[CV_BadDepth]

[CV_BadAlphaChannel]

[CV_BadOrder]

[CV_BadOrigin]

[CV_BadAlign]

[CV_BadCallBack]

[CV_BadTileSize]

[CV_BadCOI]

[CV_BadROISize]

[CV_MaskIsTiled]

null pointer [CV_StsNullPtr]

incorrect vector length [CV_StsVecLengthErr]

incorr. filter structure content [CV_StsFilterStructContentErr]

incorr. transform kernel content [CV_StsKernelStructContentErr]

incorrect filter ofset value [CV_StsFilterOffsetErr]

the input/output structure size is incorrect [CV_StsBadSize]

division by zero [CV_StsDivByZero]

in-place operation is not supported [CV_StsInplaceNotSupported]

request can't be completed [CV_StsObjectNotFound]

formats of input/output arrays differ [CV_StsUnmatchedFormats]

flag is wrong or not supported [CV_StsBadFlag]

bad CvPoint [CV_StsBadPoint]

bad format of mask (neither 8uC1 nor 8sC1) [CV_StsBadMask]

sizes of input/output structures do not match [CV_StsUnmatchedSizes]

the data format/type is not supported by the function [CV_StsUnsupportedFormat]

some of parameters are out of range [CV_StsOutOfRange]

invalid syntax/structure of the parsed file [CV_StsParseError]

the requested function/feature is not implemented [CV_StsNotImplemented]

an allocated block has been corrupted [CV_StsBadMemBlock]

assertion failed

Output string format of Mat.Dump()

Default format. [1, 2, 3, 4, 5, 6; \n 7, 8, 9, ... ]

CSV format. 1, 2, 3, 4, 5, 6\n 7, 8, 9, ...

Python format. [[[1, 2, 3], [4, 5, 6]], \n [[7, 8, 9], ... ]

NumPy format. array([[[1, 2, 3], [4, 5, 6]], \n [[7, 8, 9], .... ]]], type='uint8');

C language format. {1, 2, 3, 4, 5, 6, \n 7, 8, 9, ...};

The operation flags for cv::GEMM

Transpose src1

Transpose src2

Transpose src3

Font name identifier. Only a subset of Hershey fonts (http://sources.isc.org/utils/misc/hershey-font.txt) are supported now.

normal size sans-serif font

small size sans-serif font

normal size sans-serif font (more complex than HERSHEY_SIMPLEX)

normal size serif font

normal size serif font (more complex than HERSHEY_COMPLEX)

smaller version of HERSHEY_COMPLEX

hand-writing style font

more complex variant of HERSHEY_SCRIPT_SIMPLEX

flag for italic font

Miscellaneous flags for cv::kmeans

Select random initial centers in each attempt.

Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].

During the first (and possibly the only) attempt, use the user-supplied labels instead of computing them from the initial centers. For the second and further attempts, use the random or semi-random centers. Use one of KMEANS_\*_CENTERS flag to specify the exact method.

cv::utils::logging::LogLevel

for using in setLogVevel() call

Fatal (critical) error (unrecoverable internal error)

Error message.

Warning message.

Info message.

Debug message. Disabled in the "Release" build.

Verbose (trace) messages. Requires verbosity level. Disabled in the "Release" build.

diagonal type

a diagonal from the upper half [< 0]

Main diagonal [= 0]

a diagonal from the lower half [> 0]

Type of norm

The L1-norm (sum of absolute values) of the array is normalized.

The (Euclidean) L2-norm of the array is normalized.

The array values are scaled and shifted to the specified range.

The dimension index along which the matrix is reduce.

The matrix is reduced to a single row. [= 0]

The matrix is reduced to a single column. [= 1]

The dimension is chosen automatically by analysing the dst size. [= -1]

The reduction operations for cvReduce

https://github.com/opencv/opencv/blob/37c12db3668a1fbbfdb286be59f662c67cfbfea1/modules/core/include/opencv2/core.hpp#L231

The output is the sum of all the matrix rows/columns.

The output is the mean vector of all the matrix rows/columns.

The output is the maximum (column/row-wise) of all the matrix rows/columns.

The output is the minimum (column/row-wise) of all the matrix rows/columns.

an enum to specify how to rotate the array.

Rotate 90 degrees clockwise

Rotate 180 degrees clockwise

Rotate 270 degrees clockwise

return codes for cv::solveLP() function

problem is unbounded (target function can achieve arbitrary high values)

problem is unfeasible (there are no points that satisfy all the constraints imposed)

there is only one maximum for target function

there are multiple maxima for target function - the arbitrary one is returned

Signals an error and raises the exception.

each matrix row is sorted independently

each matrix column is sorted independently; this flag and the previous one are mutually exclusive.

each matrix row is sorted in the ascending order.

each matrix row is sorted in the descending order; this flag and the previous one are also mutually exclusive.

cv::UMatUsageFlags

File Storage Node class

The default constructor

Initializes from cv::FileNode*

Releases unmanaged resources

Returns the node content as an integer. If the node stores floating-point number, it is rounded.

Returns the node content as float

Returns the node content as System.Single

Returns the node content as double

Returns the node content as text string

Returns the node content as OpenCV Mat

returns element of a mapping node

returns element of a sequence node

Returns true if the node is empty

Returns true if the node is a "none" object

Returns true if the node is a sequence

Returns true if the node is a mapping

Returns true if the node is an integer

Returns true if the node is a floating-point number

Returns true if the node is a text string

Returns true if the node has a name

Returns the node name or an empty string if the node is nameless

Returns the number of elements in the node, if it is a sequence or mapping, or 1 otherwise.

Returns type of the node.

Type of the node.

returns iterator pointing to the first node element

returns iterator pointing to the element following the last node element

Get FileNode iterator

Reads node elements to the buffer with the specified format

Reads the node element as Int32 (int)

Reads the node element as Single (float)

Reads the node element as Double

Reads the node element as String

Reads the node element as Mat

Reads the node element as SparseMat

Reads the node element as KeyPoint[]

Reads the node element as DMatch[]

Reads the node element as Range

Reads the node element as KeyPoint

Reads the node element as DMatch

Reads the node element as Point

Reads the node element as Point2f

Reads the node element as Point2d

Reads the node element as Point3i

Reads the node element as Point3f

Reads the node element as Point3d

Reads the node element as Size

Reads the node element as Size2f

Reads the node element as Size2d

Reads the node element as Rect

Reads the node element as Rect2f

Reads the node element as Rect2d

Reads the node element as Scalar

Reads the node element as Vector

type of the file storage node

empty node

an integer

floating-point number

synonym or REAL

text string in UTF-8 encoding

synonym for STR

sequence

mapping

compact representation of a sequence or mapping. Used only by YAML writer

if set, means that all the collection elements are numbers of the same type (real's or int's). UNIFORM is used only when reading FileStorage; FLOW is used only when writing. So they share the same bit

empty structure (sequence or mapping)

the node has a name (i.e. it is element of a mapping)

File Storage Node class

The default constructor

Initializes from cv::FileNode*

Releases unmanaged resources

Reads node elements to the buffer with the specified format. Usually it is more convenient to use operator `>>` instead of this method.

Specification of each array element.See @ref format_spec "format specification" Pointer to the destination array. Number of elements to read. If it is greater than number of remaining elements then all of them will be read.

*iterator

IEnumerable<T>.Reset

iterator++

iterator += ofs

Reads node elements to the buffer with the specified format. Usually it is more convenient to use operator `>>` instead of this method.

XML/YAML File Storage Class.

Default constructor. You should call FileStorage::open() after initialization.

The full constructor

Name of the file to open or the text string to read the data from. Extension of the file (.xml or .yml/.yaml) determines its format (XML or YAML respectively). Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify the output file format (e.g. mydata.xml, .yml etc.). Encoding of the file. Note that UTF-16 XML encoding is not supported currently and you should use 8-bit encoding instead of it.

Releases unmanaged resources

Returns the specified element of the top-level mapping

the currently written element

the writer state

operator that performs PCA. The previously stored data, if any, is released

Name of the file to open or the text string to read the data from. Extension of the file (.xml, .yml/.yaml or .json) determines its format (XML, YAML or JSON respectively). Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify the output file format (e.g. mydata.xml, .yml etc.). A file name can also contain parameters. You can use this format, "*?base64" (e.g. "file.json?base64" (case sensitive)), as an alternative to FileStorage::BASE64 flag. Mode of operation. Encoding of the file. Note that UTF-16 XML encoding is not supported currently and you should use 8-bit encoding instead of it.

Returns true if the object is associated with currently opened file.

Closes the file and releases all the memory buffers

Closes the file, releases all the memory buffers and returns the text string

Returns the first element of the top-level mapping

The first element of the top-level mapping.

Returns the top-level mapping. YAML supports multiple streams

Zero-based index of the stream. In most cases there is only one stream in the file. However, YAML supports multiple streams and so there can be several. The top-level mapping.

Writes one or more numbers of the specified format to the currently written structure

Specification of each array element, see @ref format_spec "format specification" Pointer to the written array. Number of the uchar elements to write.

Writes a comment. The function writes a comment into file storage. The comments are skipped when the storage is read.

The written comment, single-line or multi-line If true, the function tries to put the comment at the end of current line. Else if the comment is multi-line, or if it does not fit at the end of the current line, the comment starts a new line.

Returns the normalized object name for the specified file name

Writes data to a file storage.

/Writes data to a file storage.

Writes data to a file storage.

File storage mode

The storage is open for reading

The storage is open for writing

The storage is open for appending

flag, read data from source or write data to the internal buffer (which is returned by FileStorage::release)

flag, auto format

flag, XML format

flag, YAML format

flag, write rawdata in Base64 by default. (consider using WRITE_BASE64)

flag, enable both WRITE and BASE64

Proxy data type for passing Mat's and vector<>'s as input parameters

Constructor

Releases managed resources

Releases unmanaged resources

Creates a proxy class of the specified Mat

Creates a proxy class of the specified MatExpr

Creates a proxy class of the specified Scalar

Creates a proxy class of the specified double

Creates a proxy class of the specified array of Mat

Creates a proxy class of the specified list

Array object

Creates a proxy class of the specified list

Array object Matrix depth and channels for converting array to cv::Mat

Creates a proxy class of the specified list

Array object

Creates a proxy class of the specified list

Array object Matrix depth and channels for converting array to cv::Mat

Creates a proxy class of the specified list

Array object

Creates a proxy class of the specified list

Array object Matrix depth and channels for converting array to cv::Mat

Creates a proxy class of the specified Vec*b

Proxy data type for passing Mat's and vector<>'s as input parameters. Synonym for OutputArray.

Constructor

Creates a proxy class of the specified Mat

Creates a proxy class of the specified UMat

Linear Discriminant Analysis

constructor

Initializes and performs a Discriminant Analysis with Fisher's Optimization Criterion on given data in src and corresponding labels in labels.If 0 (or less) number of components are given, they are automatically determined for given data in computation.

Releases unmanaged resources

Returns the eigenvectors of this LDA.

Returns the eigenvalues of this LDA.

Serializes this object to a given filename.

Deserializes this object from a given filename.

Serializes this object to a given cv::FileStorage.

Deserializes this object from a given cv::FileStorage.

Compute the discriminants for data in src (row aligned) and labels.

Projects samples into the LDA subspace. src may be one or more row aligned samples.

Reconstructs projections from the LDA subspace. src may be one or more row aligned projections.

Matrix expression

Constructor

Releases unmanaged resources

Convert to cv::Mat

Convert cv::Mat to cv::MatExpr

Extracts a rectangular submatrix.

Creates a matrix header for the specified matrix row.

A 0-based row index.

Creates a matrix header for the specified matrix column.

A 0-based column index.

Extracts a diagonal from a matrix

d index of the diagonal, with the following values: - d=0 is the main diagonal. - d<0 is a diagonal from the lower half. For example, d=-1 means the diagonal is set immediately below the main one. - d>0 is a diagonal from the upper half. For example, d=1 means the diagonal is set immediately above the main one.

Extracts a rectangular submatrix.

Transposes a matrix.

Inverses a matrix.

Performs an element-wise multiplication or division of the two matrices.

Another array of the same type and the same size as this, or a matrix expression. Optional scale factor.

Performs an element-wise multiplication or division of the two matrices.

Another array of the same type and the same size as this, or a matrix expression. Optional scale factor.

Computes a cross-product of two 3-element vectors.

Another cross-product operand.

Computes a dot-product of two vectors.

another dot-product operand.

Returns the size of a matrix element.

Returns the type of a matrix element.

Computes absolute value of each matrix element

OpenCV C++ n-dimensional dense array class (cv::Mat)

typeof(T) -> MatType

Creates from native cv::Mat* pointer

Creates empty Mat

Loads an image from a file. (cv::imread)

Name of file to be loaded. Specifies color type of the loaded image

constructs 2D matrix of the specified size and type

constructs 2D matrix and fills it with the specified Scalar value.

Number of rows in a 2D array. Number of columns in a 2D array. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. An optional value to initialize each matrix element with. To set all the matrix elements to the particular value after the construction, use SetTo(Scalar s) method .

constructs 2D matrix and fills it with the specified Scalar value.

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. An optional value to initialize each matrix element with. To set all the matrix elements to the particular value after the construction, use SetTo(Scalar s) method .

creates a matrix header for a part of the bigger matrix

Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied by these constructors. Instead, the header pointing to m data or its sub-array is constructed and associated with it. The reference counter, if any, is incremented. So, when you modify the matrix formed using such a constructor, you also modify the corresponding elements of m . If you want to have an independent copy of the sub-array, use Mat::clone() . Range of the m rows to take. As usual, the range start is inclusive and the range end is exclusive. Use Range.All to take all the rows. Range of the m columns to take. Use Range.All to take all the columns.

creates a matrix header for a part of the bigger matrix

Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied by these constructors. Instead, the header pointing to m data or its sub-array is constructed and associated with it. The reference counter, if any, is incremented. So, when you modify the matrix formed using such a constructor, you also modify the corresponding elements of m . If you want to have an independent copy of the sub-array, use Mat.Clone() . Array of selected ranges of m along each dimensionality.

creates a matrix header for a part of the bigger matrix

constructor for matrix headers pointing to user-allocated data

Number of rows in a 2D array. Number of columns in a 2D array. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically de-allocated, so you should take care of it. Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize() .

constructor for matrix headers pointing to user-allocated data

Number of rows in a 2D array. Number of columns in a 2D array. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically de-allocated, so you should take care of it. Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize() .

constructor for matrix headers pointing to user-allocated data

Number of rows in a 2D array. Number of columns in a 2D array. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically de-allocated, so you should take care of it. Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize() .

constructor for matrix headers pointing to user-allocated data

Number of rows in a 2D array. Number of columns in a 2D array. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically de-allocated, so you should take care of it. Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize() .

constructor for matrix headers pointing to user-allocated data

Array of integers specifying an n-dimensional array shape. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically de-allocated, so you should take care of it. Array of ndims-1 steps in case of a multi-dimensional array (the last step is always set to the element size). If not specified, the matrix is assumed to be continuous.

constructor for matrix headers pointing to user-allocated data

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape. Array type. Use MatType.CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or MatType. CV_8UC(n), ..., CV_64FC(n) to create multi-channel matrices. An optional value to initialize each matrix element with. To set all the matrix elements to the particular value after the construction, use SetTo(Scalar s) method .

Releases the resources

Releases unmanaged resources

Creates the Mat instance from System.IO.Stream

Creates the Mat instance from image data (using cv::decode)

Reads image from the specified buffer in memory.

The input slice of bytes. The same flags as in imread

Creates the Mat instance from image data (using cv::decode)

Reads image from the specified buffer in memory.

The input slice of bytes. The same flags as in imread

Extracts a diagonal from a matrix, or creates a diagonal matrix.

One-dimensional matrix that represents the main diagonal.

Returns a zero array of the specified size and type.

Number of rows. Number of columns. Created matrix type.

Returns a zero array of the specified size and type.

Alternative to the matrix size specification Size(cols, rows) . Created matrix type.

Returns a zero array of the specified size and type.

Created matrix type.

Returns an array of all 1’s of the specified size and type.

Number of rows. Number of columns. Created matrix type.

Returns an array of all 1’s of the specified size and type.

Alternative to the matrix size specification Size(cols, rows) . Created matrix type.

Returns an array of all 1’s of the specified size and type.

Created matrix type. Array of integers specifying the array shape.

Returns an identity matrix of the specified size and type.

Alternative to the matrix size specification Size(cols, rows) . Created matrix type.

Returns an identity matrix of the specified size and type.

Number of rows. Number of columns. Created matrix type.

Initializes as N x 1 matrix and copies array data to this

Source array data to be copied to this

Initializes as M x N matrix and copies array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copies array data to this

Source array data to be copied to this

operator <

operator <=

operator ==

operator !=

operator >

operator >=

Extracts a rectangular submatrix.

Start row of the extracted submatrix. The upper boundary is not included. End row of the extracted submatrix. The upper boundary is not included. Start column of the extracted submatrix. The upper boundary is not included. End column of the extracted submatrix. The upper boundary is not included.

Extracts a rectangular submatrix.

Start and end row of the extracted submatrix. The upper boundary is not included. To select all the rows, use Range.All(). Start and end column of the extracted submatrix. The upper boundary is not included. To select all the columns, use Range.All().

Extracts a rectangular submatrix.

Extracted submatrix specified as a rectangle.

Extracts a rectangular submatrix.

Array of selected ranges along each array dimension.

Retrieve UMat from Mat

Creates a matrix header for the specified matrix column.

A 0-based column index.

Creates a matrix header for the specified column span.

An inclusive 0-based start index of the column span. An exclusive 0-based ending index of the column span.

Creates a matrix header for the specified column span.

Creates a matrix header for the specified matrix row.

A 0-based row index.

Creates a matrix header for the specified row span.

Single-column matrix that forms a diagonal matrix or index of the diagonal, with the following values:

Creates a full copy of the matrix.

Returns the partial Mat of the specified Mat

Copies the matrix to another one.

Destination matrix. If it does not have a proper size or type before the operation, it is reallocated. Operation mask. Its non-zero elements indicate which matrix elements need to be copied.

Copies the matrix to another one.

Destination matrix. If it does not have a proper size or type before the operation, it is reallocated. Operation mask. Its non-zero elements indicate which matrix elements need to be copied.

Converts an array to another data type with optional scaling.

output matrix; if it does not have a proper size or type before the operation, it is reallocated. desired output matrix type or, rather, the depth since the number of channels are the same as the input has; if rtype is negative, the output matrix will have the same type as the input. optional scale factor. optional delta added to the scaled values.

Provides a functional form of convertTo.

Destination array. Desired destination array depth (or -1 if it should be the same as the source type).

Sets all or some of the array elements to the specified value.

Changes the shape and/or the number of channels of a 2D matrix without copying the data.

New number of channels. If the parameter is 0, the number of channels remains the same. New number of rows. If the parameter is 0, the number of rows remains the same.

Changes the shape and/or the number of channels of a 2D matrix without copying the data.

New number of channels. If the parameter is 0, the number of channels remains the same. New number of rows. If the parameter is 0, the number of rows remains the same.

Transposes a matrix.

Inverses a matrix.

Matrix inversion method

Performs an element-wise multiplication or division of the two matrices.

Computes a cross-product of two 3-element vectors.

Another cross-product operand.

Computes a dot-product of two vectors.

another dot-product operand.

Allocates new array data if needed.

New number of rows. New number of columns. New matrix type.

Allocates new array data if needed.

Alternative new matrix size specification: Size(cols, rows) New matrix type.

Allocates new array data if needed.

Array of integers specifying a new array shape. New matrix type.

Reserves space for the certain number of rows. The method reserves space for sz rows. If the matrix already has enough space to store sz rows, nothing happens. If the matrix is reallocated, the first Mat::rows rows are preserved. The method emulates the corresponding method of the STL vector class.

Number of rows.

Reserves space for the certain number of bytes. The method reserves space for sz bytes. If the matrix already has enough space to store sz bytes, nothing happens. If matrix has to be reallocated its previous content could be lost.

Number of bytes.

Changes the number of matrix rows.

New number of rows.

Changes the number of matrix rows.

New number of rows. Value assigned to the newly added elements.

removes several hyper-planes from bottom of the matrix (Mat.pop_back)