OpenCvSharp.CPlusPlus

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

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

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.

IListの要素にvaluesを設定する

detects corners using FAST algorithm by E. Rosten

Draw keypoints.

Draws matches of keypints from two images on output image.

restores the damaged image areas using one of the available intpainting algorithms

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

Modification of fastNlMeansDenoisingMulti function for colored images sequences

You need to call this method before using SIFT/SURF functions.

Updates motion history image using the current silhouette

Silhouette mask that has non-zero pixels where the motion occurs. Motion history image that is updated by the function (single-channel, 32-bit floating-point). Current time in milliseconds or other units. Maximal duration of the motion track in the same units as timestamp .

Computes the motion gradient orientation image from the motion history image

Motion history single-channel floating-point image. Output mask image that has the type CV_8UC1 and the same size as mhi. Its non-zero elements mark pixels where the motion gradient data is correct. Output motion gradient orientation image that has the same type and the same size as mhi. Each pixel of the image is a motion orientation, from 0 to 360 degrees. Minimal (or maximal) allowed difference between mhi values within a pixel neighborhood. Maximal (or minimal) allowed difference between mhi values within a pixel neighborhood. That is, the function finds the minimum ( m(x,y) ) and maximum ( M(x,y) ) mhi values over 3x3 neighborhood of each pixel and marks the motion orientation at (x, y) as valid only if: min(delta1, delta2) <= M(x,y)-m(x,y) <= max(delta1, delta2).

Computes the global orientation of the selected motion history image part

Motion gradient orientation image calculated by the function CalcMotionGradient() . Mask image. It may be a conjunction of a valid gradient mask, also calculated by CalcMotionGradient() , and the mask of a region whose direction needs to be calculated. Motion history image calculated by UpdateMotionHistory() . Timestamp passed to UpdateMotionHistory() . Maximum duration of a motion track in milliseconds, passed to UpdateMotionHistory() .

Splits a motion history image into a few parts corresponding to separate independent motions (for example, left hand, right hand).

Motion history image. Image where the found mask should be stored, single-channel, 32-bit floating-point. Vector containing ROIs of motion connected components. Current time in milliseconds or other units. Segmentation threshold that is recommended to be equal to the interval between motion history “steps” or greater.

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

Estimates the best-fit Euqcidean, similarity, affine or perspective transformation that maps one 2D point set to another or one image to another.

First input 2D point set stored in std::vector or Mat, or an image stored in Mat. Second input 2D point set of the same size and the same type as A, or another image. If true, the function finds an optimal affine transformation with no additional restrictions (6 degrees of freedom). Otherwise, the class of transformations to choose from is limited to combinations of translation, rotation, and uniform scaling (5 degrees of freedom).

computes dense optical flow using Simple Flow algorithm

First 8-bit 3-channel image. Second 8-bit 3-channel image Estimated flow Number of layers Size of block through which we sum up when calculate cost function for pixel maximal flow that we search at each level vector smooth spatial sigma parameter vector smooth color sigma parameter window size for postprocess cross bilateral filter spatial sigma for postprocess cross bilateralf filter color sigma for postprocess cross bilateral filter threshold for detecting occlusions window size for bilateral upscale operation spatial sigma for bilateral upscale operation color sigma for bilateral upscale operation threshold to detect point with irregular flow - where flow should be recalculated after upscale

Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method

Create Bilateral TV-L1 Super Resolution.

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 vector to rotation matrix using Rodrigues transformation

Input rotation vector (3x1). Output rotation matrix (3x3).

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.

converts rotation matrix to rotation vector using Rodrigues transformation

Input rotation matrix (3x3). Output rotation vector (3x1).

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.

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.

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. Number of inliers. If the algorithm at some stage finds more inliers than minInliersCount , it finishes. 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.

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.

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.

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.

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.

Creates a window.

Name of the window in the window caption that may be used as a window identifier.

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.

Displays the image in the specified window

Name of the window. Image to be shown.

Loads an image from a file.

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

Saves an image to a specified file.

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

Compresses the image and stores it in the memory buffer

The file extension that defines the output format The image to be written

Compresses the image and stores it in the memory buffer

The file extension that defines the output format The image to be written

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.

Resizes window to the specified size

Window name The new window width The new window height

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.

Changes parameters of a window dynamically.

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

Provides parameters of a window.

Name of the window. Window property to retrieve.

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

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

utility function: convert one image to another with optional vertical flip

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.

Extract the selected image channel

The source array. It should be a pointer to CvMat or IplImage The destination array; will have single-channel, and the same size and the same depth as src If the parameter is >=0, it specifies the channel to extract; If it is <0, src must be a pointer to IplImage with valid COI set - then the selected COI is extracted. [By default this is -1]

[By default this is -1]

Computes absolute value of each matrix element

matrix

Computes absolute value of each matrix element

matrix expression

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]

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

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 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.

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

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

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)

computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

The first source array The inclusive lower boundary array of the same size and type as src The exclusive upper boundary array of the same size and type as src The destination array, will have the same size as src and CV_8U type

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

compares elements of two arrays (dst = src1 [cmpop] src2)

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

The source array

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

The source array

computes cube root of the argument

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

converts polar coordinates to Cartesian

converts Cartesian coordinates to polar

computes angle (angle(i)) of each (x(i), y(i)) vector

computes magnitude (magnitude(i)) of each (x(i), y(i)) vector

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

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 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. Optional index of largest eigenvalue/-vector to calculate. Optional index of smallest eigenvalue/-vector to calculate.

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 Optional index of largest eigenvalue/-vector to calculate. Optional index of smallest eigenvalue/-vector to calculate.

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

computes covariation matrix of a set of samples

computes SVD of src

performs back substitution for the previously computed SVD

computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation 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

computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication

computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently

clusters the input data using k-Means algorithm

returns 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. The optional random number generator used for shuffling. If it is null, theRng() is used instead.

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 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 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]

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

draws one or more polygonal curves

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

renders text string in the image

returns bounding box of the text string

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

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

Applies the adaptive bilateral filter to an image.

The source image The destination image; will have the same size and the same type as src The kernel size. This is the neighborhood where the local variance will be calculated, and where pixels will contribute (in a weighted manner). 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. Maximum allowed sigma color (will clamp the value calculated in the ksize neighborhood. Larger value of the parameter means that more dissimilar 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. The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center Pixel extrapolation method.

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

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 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]

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 circles in a grayscale image using a Hough transform.

The 8-bit, single-channel, grayscale input image Currently, the only implemented method is HoughCirclesMethod.Gradient 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.

Inverts an affine transformation.

Original affine transformation. Output reverse affine transformation.

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.

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.

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)

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

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.

GrabCut mask value [background]

GrabCut mask value [foreground]

GrabCut mask value [most probably background]

GrabCut mask value [most probably foreground]

builds the discrete Voronoi diagram

computes the distance transform map

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.

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.

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

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

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.

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

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

matches two contours using one of the available algorithms

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 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.

IEnumerable<T> extension methods for .NET Framework 2.0

Enumerable.Select

Enumerable.Select -> ToArray

Enumerable.Where

Enumerable.Where -> ToArray

Enumerable.ToArray

Enumerable.Any

Enumerable.All

Enumerable.Count

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

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.

Pointer to algorithm information (cv::AlgorithmInfo*)

Trains a FaceRecognizer.

Updates a FaceRecognizer.

Gets a prediction from a FaceRecognizer.

Predicts the label and confidence for a given sample.

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.

Flags for applyColorMap

Transformation flags for cv::dct

Zero [0]

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

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. [DFT_ROWS]

Transformation flags for cv::dft

Zero [0]

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

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

then the function performs forward transformation of 1D or 2D real array, the result, though being a complex array, has complex-conjugate symmetry ( CCS ), see the description below. Such an array can be packed into 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 the full complex array (for simpler spectrum analysis etc.). Pass the flag to tell the function to produce full-size complex output array. [DFT_COMPLEX_OUTPUT]

then the function performs inverse transformation of 1D or 2D complex array, the result is normally a complex array of the same size. However, if the source array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag), then the output is 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 real array and inverse transformation is executed, the function treats the input as packed complex-conjugate symmetrical array, so the output will also be real array [DFT_REAL_OUTPUT]

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.

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.

Returns the specified element of the top-level mapping

the currently written element

the stack of written structures

the writer state

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

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

Returns the top-level mapping. YAML supports multiple streams

Returns pointer to the underlying C FileStorage structure

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

Writes the registered C structure (CvMat, CvMatND, CvSeq). See cvWrite()

Returns the normalized object name for the specified file name

File Storage Node class

The default constructor

The full constructor wrapping CvFileNode structure.

The copy constructor

Initializes from cv::FileNode*

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 double

Returns the node content as text string

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 pointer to the underlying C FileStorage structure

Reads node elements to the buffer with the specified format

Reads the registered object and returns pointer to it

Matrix expression

Computes absolute value of each matrix element

A matrix whose element is 32SC1 (cv::Mat_<int>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

Number of rows in a 2D array. Number of columns in a 2D array. 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 .

constucts 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. 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. 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 deallocated, 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. 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 deallocated, 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.

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape. 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 .

converts old-style CvMat to the new matrix; the data is not copied by default

Old style CvMat object Flag to specify whether the underlying data of the the old-style CvMat should be copied to (true) or shared with (false) the newly constructed matrix. When the data is copied, the allocated buffer is managed using Mat reference counting mechanism. While the data is shared, the reference counter is NULL, and you should not deallocate the data until the matrix is not destructed.

converts old-style IplImage to the new matrix; the data is not copied by default

Old style IplImage object Flag to specify whether the underlying data of the the old-style IplImage should be copied to (true) or shared with (false) the newly constructed matrix. When the data is copied, the allocated buffer is managed using Mat reference counting mechanism. While the data is shared, the reference counter is NULL, and you should not deallocate the data until the matrix is not destructed.

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

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

Computes absolute value of each matrix element

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

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

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

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

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

computes sum of array elements

computes the number of nonzero array elements

number of non-zero elements in mtx

returns the list of locations of non-zero pixels

computes mean value of selected array elements

The optional operation mask

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

The output parameter: computed mean value The output parameter: computed standard deviation The optional operation mask

computes norm of the selected array part

Type of the norm The optional operation mask

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 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 global minimum and maximum array elements and returns their values and their locations

Pointer to returned minimum value Pointer to returned maximum value

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

Pointer to returned minimum location Pointer to returned maximum location

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

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

Pointer to returned minimum value Pointer to returned maximum value

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

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

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

The number of arrays must match mtx.channels() . The arrays themselves will be reallocated if needed

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

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. The destination array; will have the same size and same type as src

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

How many times the src is repeated along the vertical axis How many times the src is repeated along the horizontal axis

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

The inclusive lower boundary array of the same size and type as src The exclusive upper boundary array of the same size and type as src The destination array, will have the same size as src and CV_8U type

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

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

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 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 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 destination array; will have the same size and same type as src

checks that each matrix element is within the specified range.

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

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

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 destination array of the same type as src

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

The transformation matrix The destination array; will have the same size and depth as src and as many channels as mtx.rows

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

3x3 or 4x4 transformation matrix The destination array; it will have the same size and same type as src

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

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 (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

sorts independently each matrix row or each matrix column

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

sorts independently each matrix row or each matrix column

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

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

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 The destination array, which size and type depends on the flags

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

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

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

performs inverse 1D or 2D Discrete Cosine Transformation

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

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

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)

The inclusive lower boundary of the generated random numbers The exclusive upper boundary of the generated random numbers

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

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

The mean value (expectation) of the generated random numbers The standard deviation of the generated random numbers

shuffles the input array elements

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. The input/output numerical 1D array

Draws a line segment connecting two points

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

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 simple, thick or filled rectangle

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

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 a circle

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

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

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

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]

Fills a convex polygon.

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

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

renders text string in the image

Encodes an image into a memory buffer.

Encodes an image into a memory buffer. Format-specific parameters.

Encodes an image into a memory buffer.

Encodes an image into a memory buffer. Format-specific parameters.

Saves an image to a specified file.

Forms a border around the image

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

Smoothes image using median filter. The source image must have 1-, 3- or 4-channel and its depth should be CV_8U , CV_16U or CV_32F.

The aperture linear size. It must be odd and more than 1, i.e. 3, 5, 7 ... The destination array; will have the same size and the same type as src.

Blurs an image using a Gaussian filter. The input 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.

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 image must be a 8-bit or floating-point, 1-channel or 3-channel image.

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 The destination image; will have the same size and the same type as src

Applies the adaptive bilateral filter to an image.

The kernel size. This is the neighborhood where the local variance will be calculated, and where pixels will contribute (in a weighted manner). 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. Maximum allowed sigma color (will clamp the value calculated in the ksize neighborhood. Larger value of the parameter means that more dissimilar 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. The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center Pixel extrapolation method. The destination image; will have the same size and the same type as src

Smoothes image using box filter

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 The destination image; will have the same size and the same type as src

Smoothes image using normalized box filter

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 The destination image; will have the same size and the same type as src

Convolves an image with the kernel

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 The destination image. It will have the same size and the same number of channels as src

Applies separable linear filter to an image

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 The destination image; will have the same size and the same number of channels as src

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

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 The destination image; will have the same size and the same number of channels as src

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

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 The destination image; will have the same size and the same number of channels as src

Calculates the Laplacian of an image

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 Destination image; will have the same size and the same number of channels as src

Finds edges in an image using Canny algorithm.

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] The output edge map. It will have the same size and the same type as image

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

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 matrix must be 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 input matrix must be 8-bit, single-channel, binary source image. This 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.

Finds circles in a grayscale image using a Hough transform. The input matrix must be 8-bit, single-channel and grayscale.

Currently, the only implemented method is HoughCirclesMethod.Gradient 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)

Dilates an image by using a specific structuring element.

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()] The destination image. It will have the same size and the same type as src

Erodes an image by using a specific structuring element.

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()] The destination image. It will have the same size and the same type as src

Performs advanced morphological transformations

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()] Destination image. It will have the same size and the same type as src

Resizes an image.

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 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.

Applies an affine transformation to an 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.

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. output image that has the size dsize and the same type as src.

Applies a generic geometrical transformation to an image.

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. Destination image. It has the same size as map1 and the same type as src

Inverts an affine transformation.

Output reverse affine transformation.

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

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. Depth of the extracted pixels. By default, they have the same depth as src. Extracted patch that has the size patchSize and the same number of channels as src .

Adds an image to the accumulator.

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

Adds the square of a source image to the accumulator.

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

Computes a Hanning window coefficients in two dimensions.

The window size specifications Created array type

Applies a fixed-level threshold to each array element. The input matrix must be single-channel, 8-bit or 32-bit floating point.

threshold value. maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types. thresholding type (see the details below). output array of the same size and type as src.

Applies an adaptive threshold to an array. Source matrix must be 8-bit single-channel image.

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. Destination image of the same size and the same type as src.

Blurs an image and downsamples it.

size of the output image; by default, it is computed as Size((src.cols+1)/2

Upsamples an image and then blurs it.

size of the output image; by default, it is computed as Size(src.cols*2, (src.rows*2)

corrects lens distortion for the given camera matrix and distortion coefficients

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. Output (corrected) image that has the same size and type as src .

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

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. Input matrix is an observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or CV_64FC2).

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. Output ideal point coordinates after undistortion and reverse perspective transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates.

Normalizes the grayscale image brightness and contrast by normalizing its histogram. The source matrix is 8-bit single channel image.

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

Performs a marker-based image segmentation using the watershed algorithm. Input matrix is 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 matrix is 8-bit, 3-channel image.

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

Segments the image using GrabCut algorithm. The input is 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.

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.

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.

(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.

Converts image from one color space to another

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 The destination image; will have the same size and the same depth as src

Calculates all of the moments up to the third order of a polygon or rasterized shape. The input is a raster image (single-channel, 8-bit or floating-point 2D array).

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 The input is 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 Specifies the comparison method 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).

Finds contours in a binary image. The source is 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 this 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.

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.

Draws contours in the 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

Approximates contour or a curve using Douglas-Peucker algorithm. The input is the polygon or curve to approximate and it must be 1 x N or N x 1 matrix of type CV_32SC2 or CV_32FC2.

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

Calculates a contour perimeter or a curve length. The input is 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Indicates, whether the curve is closed or not

Calculates the up-right bounding rectangle of a point set. The input is 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 input is 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Finds the minimum area rotated rectangle enclosing a 2D point set. The input is 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

Finds the minimum area circle enclosing a 2D point set. The input is 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.

The output center of the circle The output radius of the circle

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

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

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

Fits ellipse to the set of 2D points.

Fits line to the set of 2D points using M-estimator algorithm. The input is vector of 2D 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 3D points using M-estimator algorithm. The input is vector of 3D points.

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

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.

computes the distance transform map

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

constucts 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 .

constucts 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() . 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 deallocated, 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 deallocated, 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 deallocated, 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 .

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Releases the resources

Creates the Mat instance from System.IO.Stream

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

sizeof(cv::Mat)

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

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.

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 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.

Creates the IplImage clone instance for the matrix.

Creates the IplImage clone instance or header for the matrix.

If true, this method returns an IplImage that is adjusted alignment; otherwise, a header of IplImage is returned.

Creates the CvMat clone instance for the matrix.

Creates the CvMat header or clone instance for the matrix.

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.

Extracts a rectangular submatrix.

Extracted submatrix specified as a rectangle.

Extracts a rectangular submatrix.

Array of selected ranges along each array dimension.

Indexer to access partial Mat as MatExpr

Mat column's indexer object

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.

Indexer to access Mat column as MatExpr

Mat row's indexer object

Creates a matrix header for the specified matrix row. [Mat::row]

A 0-based row index.

Creates a matrix header for the specified row span. (Mat::rowRange)

An inclusive 0-based start index of the row span. An exclusive 0-based ending index of the row span.

Indexer to access Mat row as MatExpr

Adjusts a submatrix size and position within the parent matrix.

Shift of the top submatrix boundary upwards. Shift of the bottom submatrix boundary downwards. Shift of the left submatrix boundary to the left. Shift of the right submatrix boundary to the right.

Provides a functional form of convertTo.

Destination array. Desired destination array depth (or -1 if it should be the same as the source type).

Provides a functional form of convertTo.

Destination array.

Returns the number of matrix channels.

Creates a full copy of the matrix.

Returns the partial Mat of the specified Mat

the number of columns or -1 when the array has more than 2 dimensions

the array dimensionality, >= 2

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.

Copies the matrix to another one.

Destination matrix. If it does not have a proper size or type before the operation, it is reallocated.

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.

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.

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

Another cross-product operand.

pointer to the data

unsafe pointer to the data

The pointer that is possible to compute a relative sub-array position in the main container array using locateROI()

Returns the depth of a matrix element.

Single-column matrix that forms a diagonal matrix or index of the diagonal, with the following values:

Computes a dot-product of two vectors.

another dot-product operand.

Returns the matrix element size in bytes.

Returns the size of each matrix element channel in bytes.

Returns true if the array has no elements.

Inverses a matrix.

Matrix inversion method

Reports whether the matrix is continuous or not.

Returns whether this matrix is a part of other matrix or not.

Locates the matrix header within a parent matrix.

Output parameter that contains the size of the whole matrix containing *this as a part. Output parameter that contains an offset of *this inside the whole matrix.

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

pointer to the reference counter; when matrix points to user-allocated data, the pointer is NULL

pointer to the reference counter

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.

the number of rows or -1 when the array has more than 2 dimensions

Sets all or some of the array elements to the specified value.

Returns a matrix size.

Returns a normalized step.

Transposes a matrix.

Returns the total number of array elements.

Returns the type of a matrix element.

Returns a string that represents this Mat.

Returns a string that represents each element value of Mat. This method corresponds to std::ostream << Mat

Makes a Mat that have the same size, depth and channels as this image

Returns a pointer to the specified matrix row.

Index along the dimension 0

Returns a pointer to the specified matrix element.

Index along the dimension 0 Index along the dimension 1

Returns a pointer to the specified matrix element.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2

Returns a pointer to the specified matrix element.

Array of Mat::dims indices.

Mat Indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Returns a value to the specified array element.

Index along the dimension 0 A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

Returns a value to the specified array element.

Array of Mat::dims indices. A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

Returns a value to the specified array element.

Array of Mat::dims indices. A value to the specified array element.

Set a value to the specified array element.

Index along the dimension 0

Set a value to the specified array element.

Index along the dimension 0 Index along the dimension 1

Set a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2

Set a value to the specified array element.

Array of Mat::dims indices.

Mat column's indexer object

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.

Indexer to access Mat column as Mat

Mat row's indexer object

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.

Indexer to access Mat row as Mat

Get the data of this matrix as array

Set the specified array data to this matrix

reserves enough space to fit sz hyper-planes

resizes matrix to the specified number of hyper-planes

resizes matrix to the specified number of hyper-planes; initializes the newly added elements

Adds elements to the bottom of the matrix. (Mat.push_back)

Added line(s)

Adds elements to the bottom of the matrix. (Mat.push_back)

Added line(s)

removes several hyper-planes from bottom of the matrix (Mat.pop_back)

Encodes an image into a memory buffer.

Encodes an image into a memory buffer. Format-specific parameters.

Encodes an image into a memory buffer.

Encodes an image into a memory buffer. Format-specific parameters.

Converts Mat to System.IO.MemoryStream

Writes image data encoded from this Mat to System.IO.Stream

Creates type-specific Mat instance from this.

Proxy datatype for passing Mat's and List<>'s as output parameters

Mersenne Twister random number generator

operations.hpp

updates the state and returns the next 32-bit unsigned integer random number

returns a random integer sampled uniformly from [0, N).

returns uniformly distributed integer random number from [a,b) range

returns uniformly distributed floating-point random number from [a,b) range

returns uniformly distributed double-precision floating-point random number from [a,b) range

sizeof(Rect)

Represents a CvRect structure with its properties left uninitialized.

Specifies whether this object contains the same members as the specified Object.

The Object to test. This method returns true if obj is the same type as this object and has the same members as this object.

Compares two Rectf objects. The result specifies whether the members of each object are equal.

A Point to compare. A Point to compare. This operator returns true if the members of left and right are equal; otherwise, false.

Compares two Rectf objects. The result specifies whether the members of each object are unequal.

A Point to compare. A Point to compare. This operator returns true if the members of left and right are unequal; otherwise, false.

Shifts rectangle by a certain offset

Expands or shrinks rectangle by a certain amount

Determines the CvRect structure that represents the intersection of two rectangles.

A rectangle to intersect. A rectangle to intersect.

Gets a CvRect structure that contains the union of two CvRect structures.

A rectangle to union. A rectangle to union.

Gets the y-coordinate of the top edge of this CvRect structure.

Gets the y-coordinate that is the sum of the Y and Height property values of this CvRect structure.

Gets the x-coordinate of the left edge of this CvRect structure.

Gets the x-coordinate that is the sum of X and Width property values of this CvRect structure.

Coordinate of the left-most rectangle corner [Point2f(X, Y)]

Size of the rectangle [CvSize(Width, Height)]

Coordinate of the left-most rectangle corner [Point2f(X, Y)]

Coordinate of the right-most rectangle corner [Point2f(X+Width, Y+Height)]

Determines if the specified point is contained within the rectangular region defined by this Rectangle.

x-coordinate of the point y-coordinate of the point

Determines if the specified point is contained within the rectangular region defined by this Rectangle.

point

Determines if the specified rectangle is contained within the rectangular region defined by this Rectangle.

rectangle

Inflates this Rect by the specified amount.

The amount to inflate this Rectangle horizontally. The amount to inflate this Rectangle vertically.

Inflates this Rect by the specified amount.

The amount to inflate this rectangle.

Creates and returns an inflated copy of the specified CvRect structure.

The Rectangle with which to start. This rectangle is not modified. The amount to inflate this Rectangle horizontally. The amount to inflate this Rectangle vertically.

Determines the CvRect structure that represents the intersection of two rectangles.

A rectangle to intersect. A rectangle to intersect.

Determines the CvRect structure that represents the intersection of two rectangles.

A rectangle to intersect.

Determines if this rectangle intersects with rect.

Rectangle

Gets a CvRect structure that contains the union of two CvRect structures.

A rectangle to union.

Gets a CvRect structure that contains the union of two CvRect structures.

A rectangle to union. A rectangle to union.

Specifies whether this object contains the same members as the specified Object.

The Object to test. This method returns true if obj is the same type as this object and has the same members as this object.

Returns a hash code for this object.

An integer value that specifies a hash value for this object.

Converts this object to a human readable string.

A string that represents this object.

Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

The constructor.

Descriptor extractor that is used to compute descriptors for an input image and its keypoints. Descriptor matcher that is used to find the nearest word of the trained vocabulary for each keypoint descriptor of the image.

Releases the resources

Sets a visual vocabulary.

Vocabulary (can be trained using the inheritor of BOWTrainer ). Each row of the vocabulary is a visual word(cluster center).

Returns the set vocabulary.

Computes an image descriptor using the set visual vocabulary.

Image, for which the descriptor is computed. Keypoints detected in the input image. Computed output image descriptor. pointIdxsOfClusters Indices of keypoints that belong to the cluster. This means that pointIdxsOfClusters[i] are keypoint indices that belong to the i -th cluster(word of vocabulary) returned if it is non-zero. Descriptors of the image keypoints that are returned if they are non-zero.

Computes an image descriptor using the set visual vocabulary.

Image, for which the descriptor is computed. Keypoints detected in the input image. Computed output image descriptor.

Returns an image descriptor size if the vocabulary is set. Otherwise, it returns 0.

Returns an image descriptor type.

Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

Releases the resources

Clusters train descriptors.

Descriptors to cluster. Each row of the descriptors matrix is a descriptor. Descriptors are not added to the inner train descriptor set. The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first variant of the method, train descriptors stored in the object are clustered.In the second variant, input descriptors are clustered.

Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

Adds descriptors to a training set.

descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a descriptor. The training set is clustered using clustermethod to construct the vocabulary.

Returns a training set of descriptors.

Returns the count of all descriptors stored in the training set.

Clusters train descriptors.

Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

Creates instance by cv::Ptr<T>

Creates instance by raw pointer T*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Return true if the matcher supports mask in match methods.

Pointer to algorithm information (cv::AlgorithmInfo*)

Add descriptors to train descriptor collection.

Descriptors to add. Each descriptors[i] is a descriptors set from one image.

Clear train descriptors collection.

Train matcher (e.g. train flann index). In all methods to match the method train() is run every time before matching. Some descriptor matchers (e.g. BruteForceMatcher) have empty implementation of this method, other matchers really train their inner structures (e.g. FlannBasedMatcher trains flann::Index). So nonempty implementation of train() should check the class object state and do traing/retraining only if the state requires that (e.g. FlannBasedMatcher trains flann::Index if it has not trained yet or if new descriptors have been added to the train collection).

BRIEF Descriptor

cv::Ptr<DescriptorExtractor>

bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw T*

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Abstract base class for computing descriptors for image keypoints.

cv::Ptr<DescriptorExtractor>

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw T*

Releases the resources

Compute the descriptors for a set of keypoints in an image.

The image. The input keypoints. Keypoints for which a descriptor cannot be computed are removed. Copmputed descriptors. Row i is the descriptor for keypoint i.param>

Compute the descriptors for a keypoints collection detected in image collection.

Image collection. Input keypoints collection. keypoints[i] is keypoints detected in images[i]. Keypoints for which a descriptor cannot be computed are removed. Descriptor collection. descriptors[i] are descriptors computed for set keypoints[i].

Return true if detector object is empty

Pointer to algorithm information (cv::AlgorithmInfo*)

Abstract base class for computing descriptors for image keypoints.

Compute the descriptors for a set of keypoints in an image.

The image. Copmputed descriptors. Row i is the descriptor for keypoint i. The input keypoints. Keypoints for which a descriptor cannot be computed are removed.

Compute the descriptors for a keypoints collection detected in image collection.

Return true if detector object is empty

The algorithm to use for selecting the initial centers when performing a k-means clustering step.

picks the initial cluster centers randomly [flann_centers_init_t::CENTERS_RANDOM]

picks the initial centers using Gonzales’ algorithm [flann_centers_init_t::CENTERS_GONZALES]

picks the initial centers using the algorithm suggested in [arthur_kmeanspp_2007] [flann_centers_init_t::CENTERS_KMEANSPP]

The FLANN nearest neighbor index class.

Constructs a nearest neighbor search index for a given dataset.

features – Matrix of type CV _ 32F containing the features(points) to index. The size of the matrix is num _ features x feature _ dimensionality. Structure containing the index parameters. The type of index that will be constructed depends on the type of this parameter.

Clean up any resources being used.

Performs a K-nearest neighbor search for multiple query points.

The query points, one per row Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Performs a K-nearest neighbor search for multiple query points.

The query points, one per row Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Performs a K-nearest neighbor search for multiple query points.

The query points, one per row Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Performs a radius nearest neighbor search for a given query point.

The query point Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Performs a radius nearest neighbor search for a given query point.

The query point Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Performs a radius nearest neighbor search for a given query point.

The query point Indices of the nearest neighbors found Distances to the nearest neighbors found Number of nearest neighbors to search for Search parameters

Saves the index to a file.

The file to save the index to

hierarchical k-means tree.

Is a number between 0 and 1 specifying the percentage of the approximate nearest-neighbor searches that return the exact nearest-neighbor. Using a higher value for this parameter gives more accurate results, but the search takes longer. The optimum value usually depends on the application. Specifies the importance of the index build time raported to the nearest-neighbor search time. In some applications it’s acceptable for the index build step to take a long time if the subsequent searches in the index can be performed very fast. In other applications it’s required that the index be build as fast as possible even if that leads to slightly longer search times. Is used to specify the tradeoff between time (index build time and search time) and memory used by the index. A value less than 1 gives more importance to the time spent and a value greater than 1 gives more importance to the memory usage. Is a number between 0 and 1 indicating what fraction of the dataset to use in the automatic parameter configuration algorithm. Running the algorithm on the full dataset gives the most accurate results, but for very large datasets can take longer than desired. In such case using just a fraction of the data helps speeding up this algorithm while still giving good approximations of the optimum parameters.

Clean up any resources being used.

When using a parameters object of this type the index created combines the randomized kd-trees and the hierarchical k-means tree.

The number of parallel kd-trees to use. Good values are in the range [1..16] The branching factor to use for the hierarchical k-means tree The maximum number of iterations to use in the k-means clustering stage when building the k-means tree. A value of -1 used here means that the k-means clustering should be iterated until convergence The algorithm to use for selecting the initial centers when performing a k-means clustering step. This parameter (cluster boundary index) influences the way exploration is performed in the hierarchical kmeans tree. When cb_index is zero the next kmeans domain to be explored is choosen to be the one with the closest center. A value greater then zero also takes into account the size of the domain.

Clean up any resources being used.

When passing an object of this type the index constructed will consist of a set of randomized kd-trees which will be searched in parallel.

The number of parallel kd-trees to use. Good values are in the range [1..16]

Clean up any resources being used.

When passing an object of this type the index constructed will be a hierarchical k-means tree.

The branching factor to use for the hierarchical k-means tree The maximum number of iterations to use in the k-means clustering stage when building the k-means tree. A value of -1 used here means that the k-means clustering should be iterated until convergence The algorithm to use for selecting the initial centers when performing a k-means clustering step. This parameter (cluster boundary index) influences the way exploration is performed in the hierarchical kmeans tree. When cb_index is zero the next kmeans domain to be explored is choosen to be the one with the closest center. A value greater then zero also takes into account the size of the domain.

Clean up any resources being used.

the index will perform a linear, brute-force search.

Clean up any resources being used.

This object type is used for loading a previously saved index from the disk.

インデックスが保存されたファイル名

Clean up any resources being used.

Functions of OpenCV GPU module

Returns the number of installed CUDA-enabled devices. Use this function before any other GPU functions calls. If OpenCV is compiled without GPU support, this function returns 0.

Returns the current device index set by SetDevice() or initialized by default.

Sets a device and initializes it for the current thread.

System index of a GPU device starting with 0.

Explicitly destroys and cleans up all resources associated with the current device in the current process. Any subsequent API call to this device will reinitialize the device.

Page-locks the matrix m memory and maps it for the device(s)

Unmaps the memory of matrix m, and makes it pageable again.

Creates continuous GPU matrix

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

Creates continuous GPU matrix

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

Creates continuous GPU matrix

Number of rows and columns in a 2D array. Array type.

Creates continuous GPU matrix

Number of rows and columns in a 2D array. Array type.

Ensures that size of the given matrix is not less than (rows, cols) size and matrix type is match specified one too

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

Ensures that size of the given matrix is not less than (rows, cols) size and matrix type is match specified one too

Number of rows and columns in a 2D array. Array type.

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

Smooths the image using the normalized box filter.

Input image. CV_8UC1 and CV_8UC4 source types are supported. Output image type. The size and type is the same as src. Output image depth. If -1, the output image has the same depth as the input one. The only values allowed here are CV_8U and -1. Kernel size. Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center. Stream for the asynchronous version.

Acts as a synonym for the normalized box filter.

Input image. CV_8UC1 and CV_8UC4 source types are supported. Output image type. The size and type is the same as src. Kernel size. Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center. Stream for the asynchronous version.

Erodes an image by using a specific structuring element.

Source image. Only CV_8UC1 and CV_8UC4 types are supported. Destination image with the same size and type as src. Structuring element used for erosion. If kernel=Mat(), a 3x3 rectangular structuring element is used. Position of an anchor within the element. The default value (-1, -1) means that the anchor is at the element center. Number of times erosion to be applied.

Erodes an image by using a specific structuring element.

Dilates an image by using a specific structuring element.

Applies an advanced morphological operation to an image.

Source image. CV_8UC1 and CV_8UC4 source types are supported. Destination image with the same size and type as src. Type of morphological operation Structuring element. Position of an anchor within the element. The default value Point(-1, -1) means that the anchor is at the element center. Number of times erosion and dilation to be applied.

Applies an advanced morphological operation to an image.

Applies the non-separable 2D linear filter to an image.

Source image. Supports CV_8U, CV_16U and CV_32F one and four channel image. Destination image. The size and the number of channels is the same as src. Desired depth of the destination image. If it is negative, it is the same as src.depth(). It supports only the same depth as the source image depth. 2D array of filter coefficients. Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor resides within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center. Pixel extrapolation method. Stream for the asynchronous version.

Applies a separable 2D linear filter to an image.

Source image. CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 source types are supported. Destination image with the same size and number of channels as src. Destination image depth. CV_8U, CV_16S, CV_32S, and CV_32F are supported. Horizontal filter coefficients. Vertical filter coefficients. Anchor position within the kernel. The default value (-1, 1) means that the anchor is at the kernel center. Pixel extrapolation method in the vertical direction. Pixel extrapolation method in the horizontal direction.

Applies a separable 2D linear filter to an image.

Applies the generalized Sobel operator to an image.

Source image. CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_16SC3, CV_32SC1, CV_32FC1 source types are supported. Destination image with the same size and number of channels as source image. Destination image depth. CV_8U, CV_16S, CV_32S, and CV_32F are supported. Derivative order in respect of x. Derivative order in respect of y. Size of the extended Sobel kernel. Possible values are 1, 3, 5 or 7. Optional scale factor for the computed derivative values. By default, no scaling is applied. Pixel extrapolation method in the vertical direction. Pixel extrapolation method in the horizontal direction.

Applies the generalized Sobel operator to an image.

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

Source image. CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_16SC3, CV_32SC1, CV_32FC1 source types are supported. Destination image with the same size and number of channels as source image. Destination image depth. CV_8U, CV_16S, CV_32S, and CV_32F are supported. Derivative order in respect of x. Derivative order in respect of y. Optional scale factor for the computed derivative values. By default, no scaling is applied. Pixel extrapolation method in the vertical direction. Pixel extrapolation method in the horizontal direction.

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

Source image. CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_16SC3, CV_32SC1, CV_32FC1 source types are supported. Destination image with the same size and number of channels as source image. Destination image depth. CV_8U, CV_16S, CV_32S, and CV_32F are supported. Derivative order in respect of x. Derivative order in respect of y. Optional scale factor for the computed derivative values. By default, no scaling is applied. Pixel extrapolation method in the vertical direction. Pixel extrapolation method in the horizontal direction. Stream for the asynchronous version.

Smooths an image using the Gaussian filter.

Source image. CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_16SC3, CV_32SC1, CV_32FC1 source types are supported. Destination image with 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. If they are zeros, they are computed from sigma1 and sigma2 . Gaussian kernel standard deviation in X direction. Gaussian kernel standard deviation in Y direction. If sigma2 is zero, it is set to be equal to sigma1 . If they are both zeros, they are computed from ksize.Width and ksize.Height, respectively. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ksize, sigma1, and sigma2. Pixel extrapolation method in the vertical direction. Pixel extrapolation method in the horizontal direction. Stream for the asynchronous version.

Applies the Laplacian operator to an image.

Source image. CV_8UC1 and CV_8UC4 source types are supported. Destination image. The size and number of channels is the same as src. Desired depth of the destination image. It supports only the same depth as the source image depth. Aperture size used to compute the second-derivative filters. It must be positive and odd. Only ksize = 1 and ksize = 3 are supported. Optional scale factor for the computed Laplacian values. Pixel extrapolation method. Stream for the asynchronous version.

Finds global minimum and maximum array elements and returns their values with locations

Single-channel source image. Pointer to the returned minimum value. Pointer to the returned maximum value. Pointer to the returned minimum location. Pointer to the returned maximum location. Optional mask to select a sub-matrix. Optional values buffer to avoid extra memory allocations. It is resized automatically. Optional locations buffer to avoid extra memory allocations. It is resized automatically.

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

Source image. CV_32F and CV_8U depth images (1..4 channels) are supported for now. Template image with the size and type the same as image. Map containing comparison results (CV_32FC1). If image is W x H and templ is w x h, then result must be W-w+1 x H-h+1. Specifies the way to compare the template with the image. Stream for the asynchronous version.

The cascade classifier class for object detection: supports old haar and new lbp xml formats and nvbin for haar cascades only.

Track whether Dispose has been called

Default constructor

CascadeClassifier_GPU Constructor

Clean up any resources being used.

releases all inner buffers

number of detected objects

An abstract class in GPU module that implements DisposableCvObject

Default constructor

Checks whether the opencv_gpu*.dll includes CUDA support.

Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm

The class implements the following algorithm: "Improved adaptive Gausian mixture model for background subtraction" Z.Zivkovic International Conference Pattern Recognition, UK, August, 2004. http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf

Track whether Dispose has been called

the default constructor

Clean up any resources being used.

The maximum allowed number of mixture components. Actual number is determined dynamically per pixel

re-initiaization method

the update operator [MOG_GPU::operator()]

Computes a background image which are the mean of all background gaussians

releases all inner buffers

Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm

Track whether Dispose has been called

the default constructor

Clean up any resources being used.

The maximum allowed number of mixture components. Actual number is determined dynamically per pixel

re-initiaization method

the update operator [MOG_GPU::operator()]

Computes a background image which are the mean of all background gaussians

releases all inner buffers

Encapculates Cuda Stream. Provides interface for async coping.

Track whether Dispose has been called

Creates from native cv::gpu::Stream* pointer

Creates empty Stream

Clean up any resources being used.

Empty stream

Downloads asynchronously. Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its subMat)

Uploads asynchronously. Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its ROI)

Copy asynchronously

Memory set asynchronously

converts matrix type, ex from float to uchar depending on type

Adds a callback to be called on the host after all currently enqueued items in the stream have completed

Not supported

TODO

[HOGDescriptor::DESCR_FORMAT_ROW_BY_ROW]

[HOGDescriptor::DESCR_FORMAT_COL_BY_COL]

Gives information about the given GPU

Creates DeviceInfo object for the current GPU

Creates DeviceInfo object for the given GPU

Releases the resources

Return compute capability versions

Checks whether device supports the given feature

Checks whether the GPU module can be run on the given device

CudaMem is limited cv::Mat with page locked memory allocation.

Track whether Dispose has been called

Creates from native cv::gpu::CudaMem* pointer

Creates empty CudaMem

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

2D array size: Size(cols, rows) Array type.

Clean up any resources being used.

returns matrix header with disabled reference counting for CudaMem data.

maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware.

includes several bit-fields: 1.the magic signature 2.continuity flag 3.depth 4.number of channels

the number of rows

the number of columns

the number of rows

the number of columns

pointer to the data

pointer to the reference counter; when matrix points to user-allocated data, the pointer is NULL

helper fields used in locateROI and adjustROI

returns true iff the GpuMatrix data is continuous (i.e. when there are no gaps between successive rows). similar to CV_IS_GpuMat_CONT(cvGpuMat->type)

Returns the number of matrix channels.

Returns the depth of a matrix element.

Returns the matrix element size in bytes.

Returns the size of each matrix element channel in bytes.

Returns a matrix size.

a distance between successive rows in bytes; includes the gap if any

Returns a normalized step.

Returns the type of a matrix element.

returns true if GpuMatrix data is NULL

returns deep copy of the matrix, i.e. the data is copied

allocates new matrix data unless the matrix already has specified size and type.

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

returns matrix header with disabled reference counting for CudaMem data.

maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware.

returns if host memory can be mapperd to gpu address space;

Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.

Track whether Dispose has been called

Creates from native cv::gpu::GpuMat* pointer

Creates empty GpuMat

constructs 2D matrix of the specified size and type

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 deallocated, 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() .

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) 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.

constructor for matrix headers pointing to user-allocated data

2D array size: Size(cols, rows) 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 deallocated, 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() .

creates a matrix for other matrix

Array that (as a whole) is assigned to the constructed matrix.

creates a matrix for other matrix

GpuMat that (as a whole) is assigned to the constructed matrix.

constucts 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 .

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

2D array size: Size(cols, rows) . 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. 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.. Region of interest.

Clean up any resources being used.

converts header to GpuMat

converts header to Mat

includes several bit-fields: 1.the magic signature 2.continuity flag 3.depth 4.number of channels

the number of rows

the number of columns

the number of rows

the number of columns

pointer to the data

pointer to the reference counter; when matrix points to user-allocated data, the pointer is NULL

helper fields used in locateROI and adjustROI

Extracts a rectangular submatrix.

GpuMat Indexer

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Set a value to the specified array element.

Index along the dimension 0 Index along the dimension 1

returns a new matrix header for the specified column span

Mat column's indexer object

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.

Indexer to access GpuMat column

returns a new matrix header for the specified row span

Mat row's indexer object

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.

Indexer to access GpuMat row

returns true iff the GpuMatrix data is continuous (i.e. when there are no gaps between successive rows). similar to CV_IS_GpuMat_CONT(cvGpuMat->type)

Returns the number of matrix channels.

Returns the depth of a matrix element.

Returns the matrix element size in bytes.

Returns the size of each matrix element channel in bytes.

Returns a matrix size.

a distance between successive rows in bytes; includes the gap if any

Returns a normalized step.

Returns the type of a matrix element.

returns true if GpuMatrix data is NULL

Pefroms blocking upload data to GpuMat.

Downloads data from device to host memory. Blocking calls.

returns deep copy of the matrix, i.e. the data is copied

copies those matrix elements to "m"

copies those matrix elements to "m" that are marked with non-zero mask elements.

converts matrix to another datatype with optional scalng. See cvConvertScale.

sets some of the matrix elements to s, according to the mask

creates alternative matrix header for the same data, with different number of channels and/or different number of rows. see cvReshape.

allocates new matrix data unless the matrix already has specified size and type. previous data is unreferenced if needed.

Number of rows in a 2D array. Number of columns in a 2D array. Array type.

allocates new matrix data unless the matrix already has specified size and type. previous data is unreferenced if needed.

2D array size: Size(cols, rows) Array type.

swaps with other smart pointer

locates matrix header within a parent matrix.

moves/resizes the current matrix ROI inside the parent matrix.

returns pointer to y-th row

Returns a string that represents this Mat.

Abstract definition of Mat indexer

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

Parent matrix object

Step byte length for each dimension

sizeof(T)

Constructor

Creates/Sets a matrix header for the specified matrix row/column.

Creates/Sets a matrix header for the specified row/column span.

Creates a matrix header for the specified matrix row/column.

Creates a matrix header for the specified row/column span.

Creates/Sets a matrix header for the specified matrix row/column.

Creates/Sets a matrix header for the specified row/column span.

HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector

setSVMDetector parameter vector

Track whether Dispose has been called

Initializes from pointer

class HOGDescriptor*

Clean up any resources being used.

Track whether Dispose has been called

Default constructor

StereoBM_GPU Constructor

Clean up any resources being used.

Class used for corner detection using the FAST algorithm.

Track whether Dispose has been called

all features have same size

Constructor.

Threshold on difference between intensity of the central pixel and pixels on a circle around this pixel. If it is true, non-maximum suppression is applied to detected corners (keypoints). Inner buffer size for keypoints store is determined as (keypointsRatio * image_width * image_height).

Clean up any resources being used.

max keypoints = keypointsRatio * img.size().area()

Releases inner buffer memory.

Finds the keypoints using FAST detector.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Finds the keypoints using FAST detector.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Download keypoints from GPU to CPU memory.

Converts keypoints from GPU representation to vector of KeyPoint.

Find keypoints and compute it’s response if nonmaxSuppression is true.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. count of detected keypoints

Gets final array of keypoints. Performs nonmax suppression if needed.

Final count of keypoints

Class for extracting ORB features and descriptors from an image.

Track whether Dispose has been called

all features have same size

Constructor.

The number of desired features. Coefficient by which we divide the dimensions from one scale pyramid level to the next. The number of levels in the scale pyramid. How far from the boundary the points should be. The level at which the image is given. If 1, that means we will also look at the image scaleFactor times bigger.

Clean up any resources being used.

Releases inner buffer memory.

Detects keypoints and computes descriptors for them.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Detects keypoints and computes descriptors for them.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Detects keypoints and computes descriptors for them.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Detects keypoints and computes descriptors for them.

Image where keypoints (corners) are detected. Only 8-bit grayscale images are supported. Optional input mask that marks the regions where we should detect features. The output vector of keypoints.

Download keypoints from GPU to CPU memory.

Converts keypoints from GPU representation to vector of KeyPoint.

Final count of keypoints

Contrast Limited Adaptive Histogram Equalization

cv::Ptr<CLAHE>

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates a predefined CLAHE object

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Decision tree node

Default constructor

The assigned to the node normalized class index (to 0..class_count-1 range), it is used internally in classification trees and tree ensembles.

The tree index in a ordered sequence of trees. The indices are used during and after the pruning procedure. The root node has the maximum value Tn of the whole tree, child nodes have Tn less than or equal to the parent's Tn, and the nodes with Tn≤CvDTree::pruned_tree_idx are not taken into consideration at the prediction stage (the corresponding branches are considered as cut-off), even if they have not been physically deleted from the tree at the pruning stage.

When true, the inverse split rule is used (i.e. left and right branches are exchanged in the expressions below)

Pointers to the parent node

Pointers to the left node

Pointers to the right node

Pointer to the first (primary) split.

The number of samples that fall into the node at the training stage. It is used to resolve the difficult cases - when the variable for the primary split is missing, and all the variables for other surrogate splits are missing too, the sample is directed to the left if left-<sample_count<right-<sample_count and to the right otherwise.

The node depth, the root node depth is 0, the child nodes depth is the parent's depth + 1.

Decision tree node split

Index of the variable used in the split

When true, the inverse split rule is used (i.e. left and right branches are exchanged in the expressions below)

The split quality, a positive number. It is used to choose the best primary split, then to choose and sort the surrogate splits. After the tree is constructed, it is also used to compute variable importance.

Pointer to the next split in the node split list.

Bit array indicating the value subset in case of split on a categorical variable. The rule is: if var_value in subset then next_node<-left else next_node<-right

The threshold value in case of split on an ordered variable. The rule is: if var_value < c then next_node<-left else next_node<-right

Used internally by the training algorithm.

Decision tree node

Track whether Dispose has been called

Default constructor

Initializes from pointer

Training constructor

Clean up any resources being used.

i-th element = k<0 - ordered, k>=0 - categorical, see k-th element of cat_* arrays

Track whether Dispose has been called

Default constructor

Clean up any resources being used.

A grid for the SVM algorithm.

Constructor

Training Parameters of Random Trees

Track whether Dispose has been called

Default constructor

Training constructor

This parameter specifies the maximum possible depth of the tree. That is the training algorithms attempts to split a node while its depth is less than max_depth. The actual depth may be smaller if the other termination criteria are met (see the outline of the training procedure in the beginning of the section), and/or if the tree is pruned. A node is not split if the number of samples directed to the node is less than the parameter value. Another stop criteria - only for regression trees. As soon as the estimated node value differs from the node training samples responses by less than the parameter value, the node is not split further. If true, surrogate splits are built. Surrogate splits are needed to handle missing measurements and for variable importance estimation. If a discrete variable, on which the training procedure tries to make a split, takes more than max_categories values, the precise best subset estimation may take a very long time (as the algorithm is exponential). Instead, many decision trees engines (including ML) try to find sub-optimal split in this case by clustering all the samples into max_categories clusters (i.e. some categories are merged together). Note that this technique is used only in N(>2)-class classification problems. In case of regression and 2-class classification the optimal split can be found efficiently without employing clustering, thus the parameter is not used in these cases. The array of a priori class probabilities, sorted by the class label value. The parameter can be used to tune the decision tree preferences toward a certain class. For example, if users want to detect some rare anomaly occurrence, the training base will likely contain much more normal cases than anomalies, so a very good classification performance will be achieved just by considering every case as normal. To avoid this, the priors can be specified, where the anomaly probability is artificially increased (up to 0.5 or even greater), so the weight of the misclassified anomalies becomes much bigger, and the tree is adjusted properly. If it is set, then variable importance is computed by the training procedure. To retrieve the computed variable importance array, call the method CvRTrees::get_var_importance(). The number of variables that are randomly selected at each tree node and that are used to find the best split(s). Termination criteria for growing the forest: term_crit.max_iter is the maximum number of trees in the forest (see also max_tree_count parameter of the constructor, by default it is set to 50) term_crit.epsilon is the sufficient accuracy (OOB error).

Clean up any resources being used.

If it is set, then variable importance is computed by the training procedure. To retrieve the computed variable importance array, call the method CvRTrees::get_var_importance().

The number of variables that are randomly selected at each tree node and that are used to find the best split(s).

Termination criteria for growing the forest: term_crit.max_iter is the maximum number of trees in the forest (see also max_tree_count parameter of the constructor, by default it is set to 50) term_crit.epsilon is the sufficient accuracy (OOB error).

SVM training parameters

Default constructor

Constructor

Type of SVM The kernel type for poly for poly/rbf/sigmoid for poly/sigmoid for SVMType.CSvc, SVMType.EpsSvr and SVMType.NuSvr for SVMType.NuSvc, SVMType.OneClass and SVMType.NuSvr for SVMType.EpsSvr for SVMType.CSvc Termination criteria

Native struct

Type of SVM

The kernel type

for poly

for poly/rbf/sigmoid

for poly/sigmoid

for SVMType.CSvc, SVMType.EpsSvr and SVMType.NuSvr

for SVMType.NuSvc, SVMType.OneClass and SVMType.NuSvr

for SVMType.EpsSvr

for SVMType.CSvc

Termination criteria

Track whether Dispose has been called

Default constructor

Clean up any resources being used.

Boosted tree classifier

Track whether Dispose has been called

Default constructor

Training constructor

Clean up any resources being used.

Trains boosted tree classifier

Predicts response for the input sample

The input sample. The optional mask of missing measurements. To handle missing measurements, the weak classifiers must include surrogate splits. The optional output parameter, a floating-point vector, of responses from each individual weak classifier. The number of elements in the vector must be equal to the slice length. The continuous subset of the sequence of weak classifiers to be used for prediction. By default, all the weak classifiers are used. The last parameter is normally set to false that implies a regular input. If it is true, the method assumes that all the values of the discrete input variables have been already normalized to 0..<num_of_categoriesi>-1 ranges. (as the decision tree uses such normalized representation internally). It is useful for faster prediction with tree ensembles. For ordered input variables the flag is not used. the output class label based on the weighted voting.

Predicts response for the input sample

The input sample. The optional mask of missing measurements. To handle missing measurements, the weak classifiers must include surrogate splits. The continuous subset of the sequence of weak classifiers to be used for prediction. By default, all the weak classifiers are used. The last parameter is normally set to false that implies a regular input. If it is true, the method assumes that all the values of the discrete input variables have been already normalized to 0..<num_of_categoriesi>-1 ranges. (as the decision tree uses such normalized representation internally). It is useful for faster prediction with tree ensembles. For ordered input variables the flag is not used. the output class label based on the weighted voting.

Removes specified weak classifiers

Deallocates memory and resets the model state

Writes the model to file storage

Reads the model from file storage

Boosting training parameters

Track whether Dispose has been called

Default constructor

Training constructor

Boosting type The number of weak classifiers to build. he weight trimming ratio, within 0..1. If the parameter is ≤0 or >1, the trimming is not used, all the samples are used at each iteration. The default value is 0.95. This parameter specifies the maximum possible depth of the tree. That is the training algorithms attempts to split a node while its depth is less than max_depth. The actual depth may be smaller if the other termination criteria are met (see the outline of the training procedure in the beginning of the section), and/or if the tree is pruned. If true, surrogate splits are built. Surrogate splits are needed to handle missing measurements and for variable importance estimation. The array of a priori class probabilities, sorted by the class label value. The parameter can be used to tune the decision tree preferences toward a certain class. For example, if users want to detect some rare anomaly occurrence, the training base will likely contain much more normal cases than anomalies, so a very good classification performance will be achieved just by considering every case as normal. To avoid this, the priors can be specified, where the anomaly probability is artificially increased (up to 0.5 or even greater), so the weight of the misclassified anomalies becomes much bigger, and the tree is adjusted properly.

Clean up any resources being used.

Boosting type

The number of weak classifiers to build.

Splitting criteria, used to choose optimal splits during a weak tree construction

The weight trimming ratio, within 0..1. If the parameter is ≤0 or >1, the trimming is not used, all the samples are used at each iteration. The default value is 0.95.

Decision tree training parameters

Track whether Dispose has been called

Default constructor

Training constructor

This parameter specifies the maximum possible depth of the tree. That is the training algorithms attempts to split a node while its depth is less than max_depth. The actual depth may be smaller if the other termination criteria are met (see the outline of the training procedure in the beginning of the section), and/or if the tree is pruned. A node is not split if the number of samples directed to the node is less than the parameter value. Another stop criteria - only for regression trees. As soon as the estimated node value differs from the node training samples responses by less than the parameter value, the node is not split further. If true, surrogate splits are built. Surrogate splits are needed to handle missing measurements and for variable importance estimation. If a discrete variable, on which the training procedure tries to make a split, takes more than max_categories values, the precise best subset estimation may take a very long time (as the algorithm is exponential). Instead, many decision trees engines (including ML) try to find sub-optimal split in this case by clustering all the samples into max_categories clusters (i.e. some categories are merged together). Note that this technique is used only in N(>2)-class classification problems. In case of regression and 2-class classification the optimal split can be found efficiently without employing clustering, thus the parameter is not used in these cases. If this parameter is >1, the tree is pruned using cv_folds-fold cross validation. If true, the tree is truncated a bit more by the pruning procedure. That leads to compact, and more resistant to the training data noise, but a bit less accurate decision tree. If true, the cut off nodes (with Tn≤CvDTree::pruned_tree_idx) are physically removed from the tree. Otherwise they are kept, and by decreasing CvDTree::pruned_tree_idx (e.g. setting it to -1) it is still possible to get the results from the original un-pruned (or pruned less aggressively) tree. The array of a priori class probabilities, sorted by the class label value. The parameter can be used to tune the decision tree preferences toward a certain class. For example, if users want to detect some rare anomaly occurrence, the training base will likely contain much more normal cases than anomalies, so a very good classification performance will be achieved just by considering every case as normal. To avoid this, the priors can be specified, where the anomaly probability is artificially increased (up to 0.5 or even greater), so the weight of the misclassified anomalies becomes much bigger, and the tree is adjusted properly.

Clean up any resources being used.

If a discrete variable, on which the training procedure tries to make a split, takes more than MaxCategories values, the precise best subset estimation may take a very long time (as the algorithm is exponential). Instead, many decision trees engines (including ML) try to find sub-optimal split in this case by clustering all the samples into MaxCategories clusters (i.e. some categories are merged together). Note that this technique is used only in N(>2)-class classification problems. In case of regression and 2-class classification the optimal split can be found efficiently without employing clustering, thus the parameter is not used in these cases.

A node is not split if the number of samples directed to the node is less than the parameter value.

If this parameter is >1, the tree is pruned using cv_folds-fold cross validation.

If true, surrogate splits are built. Surrogate splits are needed to handle missing measurements and for variable importance estimation.

If true, the tree is truncated a bit more by the pruning procedure. That leads to compact, and more resistant to the training data noise, but a bit less accurate decision tree.

If true, the cut off nodes (with Tn≤CvDTree::pruned_tree_idx) are physically removed from the tree. Otherwise they are kept, and by decreasing CvDTree::PrunedTreeIdx (e.g. setting it to -1) it is still possible to get the results from the original un-pruned (or pruned less aggressively) tree.

Another stop criteria - only for regression trees. As soon as the estimated node value differs from the node training samples responses by less than the parameter value, the node is not split further.

The array of a priori class probabilities, sorted by the class label value. The parameter can be used to tune the decision tree preferences toward a certain class. For example, if users want to detect some rare anomaly occurrence, the training base will likely contain much more normal cases than anomalies, so a very good classification performance will be achieved just by considering every case as normal. To avoid this, the priors can be specified, where the anomaly probability is artificially increased (up to 0.5 or even greater), so the weight of the misclassified anomalies becomes much bigger, and the tree is adjusted properly.

Weak tree classifier

Track whether Dispose has been called

Default constructor

Initializes by pointer

Clean up any resources being used.

Trains decision tree

Decision tree

Track whether Dispose has been called

Default constructor

Initializes by pointer

Clean up any resources being used.

Trains decision tree

Returns the leaf node of decision tree corresponding to the input vector

Reads the model from file storage

Writes the model to file storage

Deallocates memory and resets the model state

Track whether Dispose has been called

Default constructor

Initializes by pointer

Clean up any resources being used.

Track whether Dispose has been called

Default constructor

Initializes by pointer

Clean up any resources being used.

Bayes classifier for normally distributed data

Track whether Dispose has been called

Default constructor

Bayes classifier for normally distributed data

Known samples (m*n) Classes for known samples (m*1)

Bayes classifier for normally distributed data

Known samples (m*n) Classes for known samples (m*1)

Clean up any resources being used.

Trains the model

Known samples (m*n) Classes for known samples (m*1) Adds known samples to model(true) or makes a new one(false)

Trains the model

Known samples (m*n) Classes for known samples (m*1) Adds known samples to model(true) or makes a new one(false)

Predicts the response for sample(s)

Unkown samples (l*n) Classes for known samples (l*1)

Predicts the response for sample(s)

Unkown samples (l*n) Classes for known samples (l*1)

Deallocates memory and resets the model state

Writes the model to file storage

Reads the model from file storage

Random Trees

Track whether Dispose has been called

Default constructor

Initializes by pointer

Clean up any resources being used.

Trains Random Trees model

Predicts the output for the input sample

Retrieves the variable importance array

Retrieves proximity measure between two training samples

Deallocates memory and resets the model state

Writes the model to file storage

Reads the model from file storage

EM model (cv::EM)

Track whether Dispose has been called

Training constructor

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Clean up any resources being used.

Pointer to algorithm information (cv::AlgorithmInfo*)

Estimates Gaussian mixture parameters from the sample set

Predicts the response for sample

Deallocates memory and resets the model state

K nearest neighbors classifier

Track whether Dispose has been called

Default constructor

Training constructor

Known samples (m*n) Classes for known samples (m*1) Maximum number of neighbors to return

Training constructor

Known samples (m*n) Classes for known samples (m*1) Maximum number of neighbors to return

Clean up any resources being used.

Trains the model

Known samples (m*n) Classes for known samples (m*1) Maximum number of neighbors to return Adds known samples to model(true) or makes a new one(false)

Trains the model

Known samples (m*n) Classes for known samples (m*1) Maximum number of neighbors to return Adds known samples to model(true) or makes a new one(false)

Finds the K nearest neighbors of samples

Known samples (l*n) max neighbors to find Neighbors for each samples (l*k) Distance from each sample to neighbors

Finds the K nearest neighbors of samples

Known samples (l*n) max neighbors to find Neighbors for each samples (l*k) Distance from each sample to neighbors

Deallocates memory and resets the model state

Support Vector Machines

Track whether Dispose has been called

Default constructor

Training constructor

Clean up any resources being used.

Generates a grid for SVM parameters

Retrieves the number of support vectors

Retrieves the particular vector

Returns current SVM parameters

Trains SVM

Trains SVM with optimal parameters

Cross-validation parameter. The training set is divided into k_fold subsets, one subset being used to train the model, the others forming the test set. So, the SVM algorithm is executed k_fold times.

Trains SVM with optimal parameters

Cross-validation parameter. The training set is divided into k_fold subsets, one subset being used to train the model, the others forming the test set. So, the SVM algorithm is executed k_fold times.

Predicts the response for sample

Deallocates memory and resets the model state

Writes the model to file storage

Reads the model from file storage

Splitting criteria, used to choose optimal splits during a weak tree construction

Use the default criteria for the particular boosting method. [CvBoost::DEFAULT]

Use Gini index. This is default option for Real AdaBoost; may be also used for Discrete AdaBoost. [CvBoost::GINI]

Use misclassification rate. This is default option for Discrete AdaBoost; may be also used for Real AdaBoost. [CvBoost::MISCLASS]

Use least squares criteria. This is default and the only option for LogitBoost and Gentle AdaBoost.最小二乗基準を用いる． [CvBoost::SQERR]

Data layout of decision tree

Discrete AdaBoost [CvBoost::DISCRETE]

Real AdaBoost [CvBoost::REAL]

LogitBoost [CvBoost::LOGIT]

Gentle AdaBoost [CvBoost::GENTLE]

Data layout of decision tree

[CV_ROW_SAMPLE]

[CV_COL_SAMPLE]

The type of the mixture covariation matrices

A covariation matrix of each mixture is a scaled identity matrix, μk*I, so the only parameter to be estimated is μk. The option may be used in special cases, when the constraint is relevant, or as a first step in the optimization (e.g. in case when the data is preprocessed with PCA). The results of such preliminary estimation may be passed again to the optimization procedure, this time with cov_mat_type=Diagonal. [CvEM::COV_MAT_SPHERICAL]

A covariation matrix of each mixture may be arbitrary diagonal matrix with positive diagonal elements, that is, non-diagonal elements are forced to be 0's, so the number of free parameters is d for each matrix. This is most commonly used option yielding good estimation results. [CvEM::COV_MAT_DIAGONAL]

A covariation matrix of each mixture may be arbitrary symmetrical positively defined matrix, so the number of free parameters in each matrix is about d^2/2. It is not recommended to use this option, unless there is pretty accurate initial estimation of the parameters and/or a huge number of training samples. [CvEM::COV_MAT_GENERIC]

The initial step the algorithm starts from

The algorithm starts with E-step. At least, the initial values of mean vectors, CvEMParams.Means must be passed. Optionally, the user may also provide initial values for weights (CvEMParams.Weights) and/or covariation matrices (CvEMParams.Covs). [CvEM::START_E_STEP]

The algorithm starts with M-step. The initial probabilities p_i,k must be provided. [CvEM::START_M_STEP]

No values are required from the user, k-means algorithm is used to estimate initial mixtures parameters. [CvEM::START_AUTO_STEP]

Splitting criteria, used to choose optimal splits during a weak tree construction

[CvANN_MLP::IDENTITY]

U [CvANN_MLP::SIGMOID_SYM]

[CvANN_MLP::GAUSSIAN]

The MLP training algorithm to use

No flags [0]

1 - algorithm updates the network weights, rather than computes them from scratch (in the latter case the weights are initialized using Nguyen-Widrow algorithm). [CvANN_MLP::UPDATE_WEIGHTS]

algorithm does not normalize the input vectors. If this flag is not set, the training algorithm normalizes each input feature independently, shifting its mean value to 0 and making the standard deviation =1. If the network is assumed to be updated frequently, the new training data could be much different from original one. In this case user should take care of proper normalization. [CvANN_MLP::NO_INPUT_SCALE]

algorithm does not normalize the output vectors. If the flag is not set, the training algorithm normalizes each output features independently, by transforming it to the certain range depending on the activation function used. [CvANN_MLP::NO_OUTPUT_SCALE]

The MLP training algorithm to use

sequential backpropagation algorithm [CvANN_MLP_TrainParams::BACKPROP]

RPROP algorithm, default value [CvANN_MLP_TrainParams::RPROP]

The kernel type of SVM

no mapping is done, linear discrimination (or regression) is done in the original feature space. It is the fastest option. d(x,y) = x•y == (x,y) [CvSVM::LINEAR]

polynomial kernel: d(x,y) = (gamma*(x•y)+coef0)^degree [CvSVM::POLY]

radial-basis-function kernel; a good choice in most cases: d(x,y) = exp(-gamma*|x-y|^2) [CvSVM::RBF]

sigmoid function is used as a kernel: d(x,y) = tanh(gamma*(x•y)+coef0) [CvSVM::SIGMOID]

SVM params type

[CvSVM::C]

[CvSVM::GAMMA]

[CvSVM::P]

[CvSVM::NU]

[CvSVM::COEF]

[CvSVM::DEGREE]

Type of SVM

n-class classification (n>=2), allows imperfect separation of classes with penalty multiplier C for outliers. [CvSVM::C_SVC]

n-class classification with possible imperfect separation. Parameter nu (in the range 0..1, the larger the value, the smoother the decision boundary) is used instead of C. [CvSVM::NU_SVC]

one-class SVM. All the training data are from the same class, SVM builds a boundary that separates the class from the rest of the feature space. [CvSVM::ONE_CLASS]

regression. The distance between feature vectors from the training set and the fitting hyper-plane must be less than p. For outliers the penalty multiplier C is used. [CvSVM::EPS_SVR]

regression; nu is used instead of p. [CvSVM::NU_SVR]

[CV_COUNT]

[CV_PORTION]

High level image stitcher. It's possible to use this class without being aware of the entire stitching pipeline. However, to be able to achieve higher stitching stability and quality of the final images at least being familiar with the theory is recommended

Status code

Constructor

cv::Stitcher*

Creates a stitcher with the default parameters.

Flag indicating whether GPU should be used whenever it's possible.

Deletes all resources

Try to stitch the given images.

Input images. Final pano. Status code.

Try to stitch the given images.

Input images. Final pano. Status code.

Try to stitch the given images.

Input images. Region of interest rectangles. Final pano. Status code.

Try to stitch the given images.

Input images. Region of interest rectangles. Final pano. Status code.

cv::calcOpticalFlowPyrLK flags

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 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.

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

Output image matrix will be created (Mat::create), i.e. existing memory of output image may be reused. Two source image, matches and single keypoints will be drawn. For each keypoint only the center point will be drawn (without the circle around keypoint with keypoint size and orientation).

Output image matrix will not be created (Mat::create). Matches will be drawn on existing content of output image.

Single keypoints will not be drawn.

For each keypoint the circle around keypoint with keypoint size and orientation will be drawn.

cv::ORB score flags

cv::initWideAngleProjMap flags

GrabCut algorithm flags

The function initializes the state and the mask using the provided rectangle. After that it runs iterCount iterations of the algorithm. [GC_INIT_WITH_RECT]

The function initializes the state using the provided mask. Note that GC_INIT_WITH_RECT and GC_INIT_WITH_MASK can be combined. Then, all the pixels outside of the ROI are automatically initialized with GC_BGD . [GC_INIT_WITH_MASK]

The value means that the algorithm should just resume. [GC_EVAL]

Mask size for distance transform

[CV_DIST_MASK_3]

[CV_DIST_MASK_5]

[CV_DIST_MASK_PRECISE]

cv::Algorithm parameter type

Abstract definition of Mat indexer

1-dimensional indexer

Index along the dimension 0 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

Parent matrix object

Constructor

Sparse matrix class.

Creates from native cv::SparseMat* pointer

Creates empty SparseMat

constructs n-dimensional sparse matrix

converts old-style CvMat to the new matrix; the data is not copied by default

cv::Mat object

converts old-style CvSparseMat to the new matrix; the data is not copied by default

Old style CvSparseMat object

Releases the resources

sizeof(cv::Mat)

Creates the CvMat clone instance for the matrix.

Creates the CvMat header or clone instance for the matrix.

Assignment operator. This is O(1) operation, i.e. no data is copied

Assignment operator. equivalent to the corresponding constructor.

creates full copy of the matrix

copies all the data to the destination matrix. All the previous content of m is erased.

converts sparse matrix to dense matrix.

multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type

converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.

The output matrix data type. When it is =-1, the output array will have the same data type as (*this) The scale factor The optional delta added to the scaled values before the conversion

not used now

Reallocates sparse matrix. If the matrix already had the proper size and type, it is simply cleared with clear(), otherwise, the old matrix is released (using release()) and the new one is allocated.

sets all the sparse matrix elements to 0, which means clearing the hash table.

manually increments the reference counter to the header.

returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)

returns elemSize()/channels()

Returns the type of sparse matrix element.

Returns the depth of sparse matrix element.

Returns the matrix dimensionality

Returns the number of sparse matrix channels.

Returns the array of sizes, or null if the matrix is not allocated

Returns the size of i-th matrix dimension (or 0)

Computes the element hash value (1D case)

Index along the dimension 0

Computes the element hash value (2D case)

Index along the dimension 0 Index along the dimension 1

Computes the element hash value (3D case)

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2

Computes the element hash value (nD case)

Array of Mat::dims indices.

Low-level element-access function.

Index along the dimension 0 Create new element with 0 value if it does not exist in SparseMat. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Low-level element-access function.

Index along the dimension 0 Index along the dimension 1 Create new element with 0 value if it does not exist in SparseMat. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Low-level element-access function.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 Create new element with 0 value if it does not exist in SparseMat. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Low-level element-access function.

Array of Mat::dims indices. Create new element with 0 value if it does not exist in SparseMat. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, null.

Index along the dimension 0 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, null.

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, null.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, null.

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, default(T).

Index along the dimension 0 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, default(T).

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, default(T).

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Return pthe specified sparse matrix element if it exists; otherwise, default(T).

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Mat Indexer

1-dimensional indexer

Index along the dimension 0 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

3-dimensional indexer

n-dimensional indexer

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Returns a value to the specified array element.

Index along the dimension 0 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

Returns a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

Returns a value to the specified array element.

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead. A value to the specified array element.

Set a value to the specified array element.

Index along the dimension 0

Set a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Set a value to the specified array element.

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Set a value to the specified array element.

Array of Mat::dims indices. If hashVal is not null, the element hash value is not computed but hashval is taken instead.

Returns a string that represents this Mat.

MLP model

Track whether Dispose has been called

Default constructor

Training constructor

The integer vector specifies the number of neurons in each layer including the input and output layers. Specifies the activation function for each neuron Free parameter α of the activation function Free parameter β of the activation function

Training constructor

Clean up any resources being used.

Constructs the MLP with the specified topology

Trains/updates MLP

A floating-point matrix of input vectors, one vector per row. A floating-point matrix of the corresponding output vectors, one vector per row. (RPROP only) The optional floating-point vector of weights for each sample. Some samples may be more important than others for training, e.g. user may want to gain the weight of certain classes to find the right balance between hit-rate and false-alarm rate etc. The optional integer vector indicating the samples (i.e. rows of _inputs and _outputs) that are taken into account. The training params. The various parameters to control the training algorithm. the number of done iterations.

Trains/updates MLP

Predicts response for the input sample

The input sample.

Predicts response for the input sample

The input sample.

Deallocates memory and resets the model state

Writes the model to file storage

Reads the model from file storage

Parameters of MLP training algorithm

Default constructor

Training constructor

The termination criteria for the training algorithm. It identifies how many iterations is done by the algorithm (for sequential backpropagation algorithm the number is multiplied by the size of the training set) and how much the weights could change between the iterations to make the algorithm continue. The training algorithm to use

The training algorithm to use

(Backpropagation only): The coefficient to multiply the computed weight gradient by. The recommended value is about 0.1. The parameter can be set via param1 of the constructor.

(Backpropagation only): The coefficient to multiply the difference between weights on the 2 previous iterations. This parameter provides some inertia to smooth the random fluctuations of the weights. It can vary from 0 (the feature is disabled) to 1 and beyond. The value 0.1 or so is good enough. The parameter can be set via param2 of the constructor.

(RPROP only): Initial magnitude of the weight delta. The default value is 0.1. This parameter can be set via param1 of the constructor.

(RPROP only): The increase factor for the weight delta. It must be >1, default value is 1.2 that should work well in most cases, according to the algorithm's author. The parameter can only be changed explicitly by modifying the structure member.

(RPROP only): The decrease factor for the weight delta. It must be <1, default value is 0.5 that should work well in most cases, according to the algorithm's author. The parameter can only be changed explicitly by modifying the structure member.

(RPROP only): The minimum value of the weight delta. It must be >0, the default value is FLT_EPSILON. The parameter can be set via param2 of the constructor.

(RPROP only): The maximum value of the weight delta. It must be >1, the default value is 50. The parameter can only be changed explicitly by modifying the structure member.

Base class for statistical models in ML

Default constructor

Releases the resources

Deallocates memory and resets the model state

Saves the model to file

Loads the model from file

Writes the model to file storage

Reads the model from file storage

Cascade classifier class for object detection.

Track whether Dispose has been called

Default constructor

Loads a classifier from a file.

Name of the file from which the classifier is loaded.

Clean up any resources being used.

Checks whether the classifier has been loaded.

Loads a classifier from a file.

Name of the file from which the classifier is loaded. The file may contain an old HAAR classifier trained by the haartraining application or a new cascade classifier trained by the traincascade application.

Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.

Matrix of the type CV_8U containing an image where objects are detected. Parameter specifying how much the image size is reduced at each image scale. Parameter specifying how many neighbors each candidate rectangle should have to retain it. Parameter with the same meaning for an old cascade as in the function cvHaarDetectObjects. It is not used for a new cascade. Minimum possible object size. Objects smaller than that are ignored. Maximum possible object size. Objects larger than that are ignored. Vector of rectangles where each rectangle contains the detected object.

Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.

Class for grouping object candidates, detected by Cascade Classifier, HOG etc. instance of the class is to be passed to cv::partition (see cxoperations.hpp)

Find rectangular regions in the given image that are likely to contain objects and corresponding confidence levels

Structure contains the detection information.

bounding box for a detected object

confidence level

class (model or detector) ID that detect an object

Track whether Dispose has been called

Default constructor

Creates the HOG descriptor and detector.

A set of filenames storing the trained detectors (models). Each file contains one model. See examples of such files here /opencv_extra/testdata/cv/latentsvmdetector/models_VOC2007/. A set of trained models names. If it’s empty then the name of each model will be constructed from the name of file containing the model. E.g. the model stored in "/home/user/cat.xml" will get the name "cat".

Clean up any resources being used.

Clear all trained models and their names stored in an class object.

Find rectangular regions in the given image that are likely to contain objects of loaded classes (models) and corresponding confidence levels.

An image. Threshold for the non-maximum suppression algorithm. Number of threads used in parallel version of the algorithm. The detections: rectangulars, scores and class IDs.

Return the class (model) names that were passed in constructor or method load or extracted from models filenames in those methods.

Return a count of loaded models (classes).

Clear all inner buffers.

Base class for Super Resolution algorithms.

Create Bilateral TV-L1 Super Resolution.

Set input frame source for Super Resolution algorithm.

Input frame source

Process next frame from input and return output result.

Output result

Clear all inner buffers.

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

class for defined Super Resolution algorithm.

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

The Base Class for Background/Foreground Segmentation. The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.

the default constructor

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw T*

Clean up any resources being used.

Total number of distinct colors to maintain in histogram.

Set between 0.0 and 1.0, determines how quickly features are "forgotten" from histograms.

Number of frames of video to use to initialize histograms.

Number of discrete levels in each channel to be used in histograms.

Prior probability that any given pixel is a background pixel. A sensitivity parameter.

Value above which pixel is determined to be FG.

Smoothing radius, in pixels, for cleaning up FG image.

Perform background model update

Performs single-frame background subtraction and builds up a statistical background image

Input image Output mask image representing foreground and background pixels

Validate parameters and set up data structures for appropriate image size. Must call before running on data.

input frame size minimum value taken on by pixels in image sequence. Usually 0 maximum value taken on by pixels in image sequence. e.g. 1.0 or 255

Releases all inner buffers.

Pointer to algorithm information (cv::AlgorithmInfo*)

The Base Class for Background/Foreground Segmentation. The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.

cv::Ptr<FeatureDetector>

the default constructor

the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw T*

Clean up any resources being used.

the update operator

computes a background image

re-initiaization method

Pointer to algorithm information (cv::AlgorithmInfo*)

Clear all inner buffers.

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Kalman filter. The class implements standard Kalman filter \url{http://en.wikipedia.org/wiki/Kalman_filter}. However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.

the default constructor

the full constructor taking the dimensionality of the state, of the measurement and of the control vector

predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)

corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))

state transition matrix (A)

control matrix (B) (not used if there is no control)

measurement matrix (H)

process noise covariance matrix (Q)

measurement noise covariance matrix (R)

priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/

Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)

posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)

re-initializes Kalman filter. The previous content is destroyed.

computes predicted state

updates the predicted state from the measurement

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

Is tried P/Invoke once

DLL file name

Static constructor

Load DLL files dynamically using Win32 LoadLibrary

Checks whether PInvoke functions can be called

Class for computing stereo correspondence using the block matching algorithm.

Track whether Dispose has been called

Default constructor

Clean up any resources being used.

separate initialization function

computes the disparity for the two rectified 8-bit single-channel images. the disparity will be 16-bit signed (fixed-point) or 32-bit floating-point image of the same size as left.

Abstract definition of Mat indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Parent matrix object

Step byte length for each dimension

Constructor

A matrix whose element is 64FC1 (cv::Mat_<double>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 32FC6 (cv::Mat_<cv::Vec6f>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 32FC4 (cv::Mat_<cv::Vec4f>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::DMatch (cv::Mat_<cv::Vec4f>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Vec3d [CV_64FC3] (cv::Mat_<cv::Vec3d>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point [CV_64FC2] (cv::Mat_<cv::Point2d>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point [CV_32FC2] (cv::Mat_<cv::Point2f>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 16UC1 (cv::Mat_<ushort>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 16SC1 (cv::Mat_<short>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 32SC1 (cv::Mat_<int>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is 32FC1 (cv::Mat_<float>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Matrix indexer

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point [CV_32SC2] (cv::Mat_<cv::Point>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

Creates a matrix header for the specified matrix row/column.

Creates a matrix header for the specified row/column span.

Creates a matrix header for the specified matrix row/column.

Creates a matrix header for the specified row/column span.

Sets a matrix header for the specified matrix row/column.

Sets a matrix header for the specified matrix row/column span.

Creates a matrix header for the specified matrix row/column.

Creates a matrix header for the specified row/column span.

Extracts a rectangular submatrix.

Array of selected ranges along each array dimension.

Creates a matrix header for the specified matrix row/column.

Creates a matrix header for the specified row/column span.

Sets a matrix header for the specified matrix row/column.

Sets a matrix header for the specified matrix row/column span.

Type-specific abstract matrix

Element Type For return value type of re-defined Mat methods

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

constucts 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 .

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

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

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 .

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

Releases the resources

Gets type-specific indexer for accessing each element

Gets read-only enumerator

For non-generic IEnumerable

Convert this mat to managed array

Convert this mat to managed rectangular array

Creates a full copy of the matrix.

Changes the shape of channels of a 2D matrix without copying the data.

New number of rows. If the parameter is 0, the number of rows remains the same.

Changes the shape of a 2D matrix without copying the data.

New number of rows. If the parameter is 0, the number of rows remains the same.

Transposes a matrix.

Extracts a rectangular submatrix.

Extracted submatrix specified as a rectangle.

Extracts a rectangular submatrix.

Array of selected ranges along each array dimension.

Extracts a rectangular submatrix.

Extracted submatrix specified as a rectangle.

Extracts a rectangular submatrix.

Array of selected ranges along each array dimension.

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

Removes the first occurrence of a specific object from the ICollection<T>.

The object to remove from the ICollection<T>. true if item was successfully removed from the ICollection<T> otherwise, false. This method also returns false if item is not found in the original ICollection<T>.

Determines whether the ICollection<T> contains a specific value.

The object to locate in the ICollection<T>. true if item is found in the ICollection<T> otherwise, false.

Determines the index of a specific item in the list.

The object to locate in the list. The index of value if found in the list; otherwise, -1.

Removes all items from the ICollection<T>.

Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.

The one-dimensional Array that is the destination of the elements copied from ICollection<T>. The Array must have zero-based indexing. The zero-based index in array at which copying begins.

Returns the total number of matrix elements (Mat.total)

Total number of list(Mat) elements

Gets a value indicating whether the IList is read-only.

A matrix whose element is cv::Rect [CV_32SC4] (cv::Mat_<cv::Rect>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point3i [CV_32SC3] (cv::Mat_<cv::Point3i>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point3f [CV_32FC3] (cv::Mat_<cv::Point3f>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

A matrix whose element is cv::Point3d [CV_64FC3] (cv::Mat_<cv::Point3d>)

Creates empty Mat

Creates from native cv::Mat* pointer

Initializes by Mat object

Managed Mat object

constructs 2D matrix of the specified size and type

Number of rows in a 2D array. Number of columns in a 2D array.

constructs 2D matrix of the specified size and type

2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

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

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

constructs n-dimensional matrix

Array of integers specifying an n-dimensional array shape.

constructs n-dimensional matrix

converts old-style CvMat to the new matrix; the data is not copied by default

converts old-style IplImage to the new matrix; the data is not copied by default

1-dimensional indexer

Index along the dimension 0 A value to the specified array element.

2-dimensional indexer

Index along the dimension 0 Index along the dimension 1 A value to the specified array element.

3-dimensional indexer

Index along the dimension 0 Index along the dimension 1 Index along the dimension 2 A value to the specified array element.

n-dimensional indexer

Array of Mat::dims indices. A value to the specified array element.

Gets a type-specific indexer. The indexer has getters/setters to access each matrix element.

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Initializes as M x N matrix and copys array data to this

Source array data to be copied to this

Initializes as N x 1 matrix and copys array data to this

Source array data to be copied to this

Convert this mat to managed array

Convert this mat to managed rectangular array

Adds elements to the bottom of the matrix. (Mat::push_back)

Added element(s)

Template class for smart reference-counting pointers

Static constructor

Constructor

Release function

Returns Ptr<T>.obj pointer

Random Number Generator. The class implements RNG using Multiply-with-Carry algorithm.

operations.hpp

updates the state and returns the next 32-bit unsigned integer random number

returns a random integer sampled uniformly from [0, N).

returns uniformly distributed integer random number from [a,b) range

returns uniformly distributed floating-point random number from [a,b) range

returns uniformly distributed double-precision floating-point random number from [a,b) range

returns Gaussian random variate with mean zero.

Singular Value Decomposition class

the default constructor

the constructor that performs SVD

eigenvalues of the covariation matrix

mean value subtracted before the projection and added after the back projection

the operator that performs SVD. The previously allocated SVD::u, SVD::w are SVD::vt are released.

performs back substitution, so that dst is the solution or pseudo-solution of m*dst = rhs, where m is the decomposed matrix

decomposes matrix and stores the results to user-provided matrices

computes singular values of a matrix

performs back substitution

finds dst = arg min_{|dst|=1} |m*dst|

Principal Component Analysis

eigenvalues of the covariation matrix

mean value subtracted before the projection and added after the back projection

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

projects vector from the original space to the principal components subspace

reconstructs the original vector from the projection

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

Algorithm Information

Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one.

Creates instance by cv::Ptr<T>

Creates instance by raw pointer T*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Return true if the matcher supports mask in match methods.

Pointer to algorithm information (cv::AlgorithmInfo*)

FREAK implementation

Constructor

enable orientation normalization enable scale normalization scaling of the description pattern number of octaves covered by the detected keypoints (optional) user defined selected pairs

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

returns the descriptor size in bytes

returns the descriptor type

select the 512 "best description pairs"

grayscale images set set of detected keypoints correlation threshold print construction information list of best pair indexes

Pointer to algorithm information (cv::AlgorithmInfo*)

ORB implementation

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

returns the descriptor size in bytes

returns the descriptor type

Compute the ORB features on an image

Compute the ORB features and descriptors on an image

Pointer to algorithm information (cv::AlgorithmInfo*)

cv::Ptr<Feature2D>

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

Compute the descriptors for a set of keypoints in an image.

The image. The input keypoints. Keypoints for which a descriptor cannot be computed are removed. Copmputed descriptors. Row i is the descriptor for keypoint i.param>

Compute the descriptors for a keypoints collection detected in image collection.

Create descriptor matcher by type name.

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Creates instance from raw pointer T*

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Add descriptors to train descriptor collection.

Descriptors to add. Each descriptors[i] is a descriptors set from one image.

Get train descriptors collection.

Clear train descriptors collection.

Return true if there are not train descriptors in collection.

Return true if the matcher supports mask in match methods.

Find one best match for each query descriptor (if mask is empty).

Find k best matches for each query descriptor (in increasing order of distances). compactResult is used when mask is not empty. If compactResult is false matches vector will have the same size as queryDescriptors rows. If compactResult is true matches vector will not contain matches for fully masked out query descriptors.

Find best matches for each query descriptor which have distance less than maxDistance (in increasing order of distances).

Find one best match for each query descriptor (if mask is empty).

Find best matches for each query descriptor which have distance less than maxDistance (in increasing order of distances).

Good Features To Track Detector

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Detects corners using FAST algorithm by E. Rosten

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

BRISK implementation

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

returns the descriptor size in bytes

returns the descriptor type

Compute the BRISK features on an image

Compute the BRISK features and descriptors on an image

Pointer to algorithm information (cv::AlgorithmInfo*)

Class for extracting blobs from an image.

SimpleBlobDetector parameters

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

Class for generation of image features which are distributed densely and regularly over the image.

The detector generates several levels (in the amount of featureScaleLevels) of features. Features of each level are located in the nodes of a regular grid over the image (excluding the image boundary of given size). The level parameters (a feature scale, a node size, a size of boundary) are multiplied by featureScaleMul with level index growing depending on input flags, viz.:

The grid node size is multiplied if this is true. Size of image boundary is multiplied if this is true.

Creates instance by cv::Ptr<cv::SURF>

Creates instance by raw pointer cv::SURF*

Creates instance from cv::Ptr<T> . ptr is disposed when the wrapper disposes.

Releases the resources

Pointer to algorithm information (cv::AlgorithmInfo*)

AVI Video File Writer

Track whether Dispose has been called

Creates video writer structure.

Name of the output video file. 4-character code of codec used to compress the frames. For example, "PIM1" is MPEG-1 codec, "MJPG" is motion-jpeg codec etc. Under Win32 it is possible to pass null in order to choose compression method and additional compression parameters from dialog. Framerate of the created video stream. Size of video frames. If it is true, the encoder will expect and encode color frames, otherwise it will work with grayscale frames (the flag is currently supported on Windows only).

Creates video writer structure.

Initializes from native pointer

CvVideoWriter*

Clean up any resources being used.

Get output video file name

Frames per second of the output vide

Get size of frame image

Get whether output frames is color or not

Creates video writer structure.

Returns true if video writer has been successfully initialized.

Writes/appends one frame to video file.

the written frame.

Video capturing class

Capture type (File or Camera)

Track whether Dispose has been called

Initializes empty capture. To use this, you should call Open.

Allocates and initialized the CvCapture structure for reading a video stream from the camera. Currently two camera interfaces can be used on Windows: Video for Windows (VFW) and Matrox Imaging Library (MIL); and two on Linux: V4L and FireWire (IEEE1394).

Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Device type

Device type Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Device type

Device type Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Allocates and initialized the CvCapture structure for reading the video stream from the specified file. After the allocated structure is not used any more it should be released by cvReleaseCapture function.

Name of the video file.

Initializes from native pointer

CvCapture*

Clean up any resources being used.

Gets the capture type (File or Camera)

Gets or sets film current position in milliseconds or video capture timestamp

Gets or sets 0-based index of the frame to be decoded/captured next

Gets or sets relative position of video file

Gets or sets width of frames in the video stream

Gets or sets height of frames in the video stream

Gets or sets frame rate

Gets or sets 4-character code of codec

Gets number of frames in video file

Gets or sets brightness of image (only for cameras)

Gets or sets contrast of image (only for cameras)

Gets or sets saturation of image (only for cameras)

Gets or sets hue of image (only for cameras)

The format of the Mat objects returned by retrieve()

A backend-specific value indicating the current capture mode

Gain of the image (only for cameras)

Exposure (only for cameras)

Boolean flags indicating whether images should be converted to RGB

TOWRITE (note: only supported by DC1394 v 2.x backend currently)

[CV_CAP_PROP_SHARPNESS]

exposure control done by camera, user can adjust refernce level using this feature [CV_CAP_PROP_AUTO_EXPOSURE]

[CV_CAP_PROP_GAMMA]

[CV_CAP_PROP_TEMPERATURE]

[CV_CAP_PROP_TRIGGER]

[CV_CAP_PROP_TRIGGER_DELAY]

[CV_CAP_PROP_WHITE_BALANCE_RED_V]

[CV_CAP_PROP_MAX_DC1394]

property for highgui class CvCapture_Android only [CV_CAP_PROP_AUTOGRAB]

readonly, tricky property, returns cpnst char* indeed [CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING]

readonly, tricky property, returns cpnst char* indeed [CV_CAP_PROP_PREVIEW_FORMAT]

[CV_CAP_PROP_OPENNI_OUTPUT_MODE]

in mm [CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH]

in mm [CV_CAP_PROP_OPENNI_BASELINE]

in pixels [CV_CAP_PROP_OPENNI_FOCAL_LENGTH]

flag [CV_CAP_PROP_OPENNI_REGISTRATION_ON]

flag that synchronizes the remapping depth map to image map by changing depth generator's view point (if the flag is "on") or sets this view point to its normal one (if the flag is "off"). [CV_CAP_PROP_OPENNI_REGISTRATION]

[CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE]

[CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE]

[CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH]

[CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON]

default is 1 [CV_CAP_GSTREAMER_QUEUE_LENGTH]

ip for anable multicast master mode. 0 for disable multicast [CV_CAP_PROP_PVAPI_MULTICASTIP]

Change image resolution by binning or skipping. [CV_CAP_PROP_XI_DOWNSAMPLING]

Output data format. [CV_CAP_PROP_XI_DATA_FORMAT]

Horizontal offset from the origin to the area of interest (in pixels). [CV_CAP_PROP_XI_OFFSET_X]

Vertical offset from the origin to the area of interest (in pixels). [CV_CAP_PROP_XI_OFFSET_Y]

Defines source of trigger. [CV_CAP_PROP_XI_TRG_SOURCE]

Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE. [CV_CAP_PROP_XI_TRG_SOFTWARE]

Selects general purpose input [CV_CAP_PROP_XI_GPI_SELECTOR]

Set general purpose input mode [CV_CAP_PROP_XI_GPI_MODE]

Get general purpose level [CV_CAP_PROP_XI_GPI_LEVEL]

Selects general purpose output [CV_CAP_PROP_XI_GPO_SELECTOR]

Set general purpose output mode [CV_CAP_PROP_XI_GPO_MODE]

Selects camera signalling LED [CV_CAP_PROP_XI_LED_SELECTOR]

Define camera signalling LED functionality [CV_CAP_PROP_XI_LED_MODE]

Calculates White Balance(must be called during acquisition) [CV_CAP_PROP_XI_MANUAL_WB]

Automatic white balance [CV_CAP_PROP_XI_AUTO_WB]

Automatic exposure/gain [CV_CAP_PROP_XI_AEAG]

Exposure priority (0.5 - exposure 50%, gain 50%). [CV_CAP_PROP_XI_EXP_PRIORITY]

Maximum limit of exposure in AEAG procedure [CV_CAP_PROP_XI_AE_MAX_LIMIT]

Maximum limit of gain in AEAG procedure [CV_CAP_PROP_XI_AG_MAX_LIMIT]

default is 1 [CV_CAP_PROP_XI_AEAG_LEVEL]

default is 1 [CV_CAP_PROP_XI_TIMEOUT]

Retrieves the specified property of camera or video file.

property identifier. property value

Retrieves the specified property of camera or video file.

property identifier. property value

Grabs the frame from camera or file. The grabbed frame is stored internally. The purpose of this function is to grab frame fast that is important for syncronization in case of reading from several cameras simultaneously. The grabbed frames are not exposed because they may be stored in compressed format (as defined by camera/driver). To retrieve the grabbed frame, cvRetrieveFrame should be used.

Returns the pointer to the image grabbed with cvGrabFrame function.

non-zero streamIdx is only valid for multi-head camera live streams

Returns the pointer to the image grabbed with cvGrabFrame function. The returned image should not be released or modified by user.

non-zero streamIdx is only valid for multi-head camera live streams

Grabs a frame from camera or video file, decompresses and returns it. This function is just a combination of cvGrabFrame and cvRetrieveFrame in one call. The returned image should not be released or modified by user.

Sets the specified property of video capturing.

property identifier. value of the property.

Sets the specified property of video capturing.

property identifier. value of the property.

Opens the specified video file

Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Device type

Device type Index of the camera to be used. If there is only one camera or it does not matter what camera to use -1 may be passed.

Closes video file or capturing device.

Returns true if video capturing has been initialized already.

For accessing each byte of Int32 value

Information about the image topology for cv::findContours

Raster image moments

spatial moments

central moments

central normalized moments

Default constructor. All moment values are set to 0.