C# Class OpenCvSharp.Cv2

OpenCV Functions of C++ I/F (cv::xxx)
Mostrar archivo Open project: shimat/opencvsharp Class Usage Examples

Public Methods

Method Description
AGAST ( InputArray image, int threshold, bool nonmaxSuppression, AGASTType type ) : KeyPoint[]

Detects corners using the AGAST algorithm

Abs ( OpenCvSharp.Mat src ) : MatExpr

Computes absolute value of each matrix element

Abs ( MatExpr src ) : MatExpr

Computes absolute value of each matrix element

Absdiff ( InputArray src1, InputArray src2, OutputArray dst ) : void

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

Accumulate ( InputArray src, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void

Adds an image to the accumulator.

AccumulateProduct ( InputArray src1, InputArray src2, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void

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

AccumulateSquare ( InputArray src, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void

Adds the square of a source image to the accumulator.

AccumulateWeighted ( InputArray src, OpenCvSharp.InputOutputArray dst, double alpha, InputArray mask ) : void

Updates a running average.

AdaptiveThreshold ( InputArray src, OutputArray dst, double maxValue, AdaptiveThresholdTypes adaptiveMethod, ThresholdTypes thresholdType, int blockSize, double c ) : void

Applies an adaptive threshold to an array.

Add ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null, int dtype = -1 ) : void

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

AddWeighted ( InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype = -1 ) : void

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

AlignSize ( int sz, int n ) : int

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.

ApplyColorMap ( InputArray src, OutputArray dst, ColormapTypes colormap ) : void

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

ApproxPolyDP ( IEnumerable curve, double epsilon, bool closed ) : Point2f[]

Approximates contour or a curve using Douglas-Peucker algorithm

ApproxPolyDP ( IEnumerable curve, double epsilon, bool closed ) : System.Point[]

Approximates contour or a curve using Douglas-Peucker algorithm

ApproxPolyDP ( InputArray curve, OutputArray approxCurve, double epsilon, bool closed ) : void

Approximates contour or a curve using Douglas-Peucker algorithm

ArcLength ( IEnumerable curve, bool closed ) : double

Calculates a contour perimeter or a curve length.

ArcLength ( IEnumerable curve, bool closed ) : double

Calculates a contour perimeter or a curve length.

ArcLength ( InputArray curve, bool closed ) : double

Calculates a contour perimeter or a curve length.

ArrowedLine ( OpenCvSharp.InputOutputArray img, System.Point pt1, System.Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift, double tipLength = 0.1 ) : void

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

BatchDistance ( InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, NormTypes normType = NormTypes.L2, int k, InputArray mask = null, int update, bool crosscheck = false ) : void

naive nearest neighbor finder

BilateralFilter ( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, BorderTypes borderType = BorderTypes.Default ) : void

Applies bilateral filter to the image

BitwiseAnd ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void

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

BitwiseNot ( InputArray src, OutputArray dst, InputArray mask = null ) : void

inverts each bit of array (dst = ~src)

BitwiseOr ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void

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

BitwiseXor ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void

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

Blur ( InputArray src, OutputArray dst, Size ksize, System.Point anchor = null, BorderTypes borderType = BorderTypes.Default ) : void

Smoothes image using normalized box filter

BoundingRect ( IEnumerable curve ) : Rect

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

BoundingRect ( IEnumerable curve ) : Rect

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

BoundingRect ( InputArray curve ) : Rect

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

BoxFilter ( InputArray src, OutputArray dst, MatType ddepth, Size ksize, System.Point anchor = null, bool normalize = true, BorderTypes borderType = BorderTypes.Default ) : void

Smoothes image using box filter

BuildOpticalFlowPyramid ( InputArray img, OpenCvSharp.Mat &pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderTypes pyrBorder = BorderTypes.Reflect101, BorderTypes derivBorder = BorderTypes.Constant, bool tryReuseInputImage = true ) : int

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

BuildOpticalFlowPyramid ( InputArray img, OutputArray pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderTypes pyrBorder = BorderTypes.Reflect101, BorderTypes derivBorder = BorderTypes.Constant, bool tryReuseInputImage = true ) : int

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

CalcBackProject ( OpenCvSharp.Mat images, int channels, InputArray hist, OutputArray backProject, OpenCvSharp.Rangef ranges, bool uniform = true ) : void

computes the joint dense histogram for a set of images.

CalcCovarMatrix ( InputArray samples, OutputArray covar, OpenCvSharp.InputOutputArray mean, CovarFlags flags ) : void

computes covariation matrix of a set of samples

CalcCovarMatrix ( InputArray samples, OutputArray covar, OpenCvSharp.InputOutputArray mean, CovarFlags flags, MatType ctype ) : void

computes covariation matrix of a set of samples

CalcCovarMatrix ( OpenCvSharp.Mat samples, OpenCvSharp.Mat covar, OpenCvSharp.Mat mean, CovarFlags flags ) : void

computes covariation matrix of a set of samples

CalcCovarMatrix ( OpenCvSharp.Mat samples, OpenCvSharp.Mat covar, OpenCvSharp.Mat mean, CovarFlags flags, MatType ctype ) : void

computes covariation matrix of a set of samples

CalcGlobalOrientation ( InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration ) : double

Computes the global orientation of the selected motion history image part

CalcHist ( OpenCvSharp.Mat images, int channels, InputArray mask, OutputArray hist, int dims, int histSize, OpenCvSharp.Rangef ranges, bool uniform = true, bool accumulate = false ) : void

computes the joint dense histogram for a set of images.

CalcHist ( OpenCvSharp.Mat images, int channels, InputArray mask, OutputArray hist, int dims, int histSize, float ranges, bool uniform = true, bool accumulate = false ) : void

computes the joint dense histogram for a set of images.

CalcMotionGradient ( InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize = 3 ) : void

Computes the motion gradient orientation image from the motion history image

CalcOpticalFlowFarneback ( InputArray prev, InputArray next, OpenCvSharp.InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, OpticalFlowFlags flags ) : void

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

CalcOpticalFlowPyrLK ( InputArray prevImg, InputArray nextImg, InputArray prevPts, OpenCvSharp.InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize = null, int maxLevel = 3, OpenCvSharp.TermCriteria criteria = null, OpticalFlowFlags flags = OpticalFlowFlags.None, double minEigThreshold = 1e-4 ) : void

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

CalcOpticalFlowPyrLK ( InputArray prevImg, InputArray nextImg, Point2f prevPts, Point2f &nextPts, byte &status, float &err, Size winSize = null, int maxLevel = 3, OpenCvSharp.TermCriteria criteria = null, OpticalFlowFlags flags = OpticalFlowFlags.None, double minEigThreshold = 1e-4 ) : void

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

CalcOpticalFlowSF ( OpenCvSharp.Mat from, OpenCvSharp.Mat to, OpenCvSharp.Mat flow, int layers, int averagingBlockSize, int maxFlow ) : void

computes dense optical flow using Simple Flow algorithm

CalibrateCamera ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, OpenCvSharp.InputOutputArray cameraMatrix, OpenCvSharp.InputOutputArray distCoeffs, OpenCvSharp.Mat &rvecs, OpenCvSharp.Mat &tvecs, CalibrationFlags flags = CalibrationFlags.None, OpenCvSharp.TermCriteria criteria = null ) : double

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

CalibrateCamera ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double cameraMatrix, double distCoeffs, Vec3d &rvecs, Vec3d &tvecs, CalibrationFlags flags = CalibrationFlags.None, OpenCvSharp.TermCriteria criteria = null ) : double

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

CalibrationMatrixValues ( InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio ) : void

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

CalibrationMatrixValues ( double cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio ) : void

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

CamShift ( InputArray probImage, Rect &window, OpenCvSharp.TermCriteria criteria ) : OpenCvSharp.RotatedRect

Finds an object center, size, and orientation.

Canny ( InputArray src, OutputArray edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false ) : void

Finds edges in an image using Canny algorithm.

CartToPolar ( InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees = false ) : void

converts Cartesian coordinates to polar

CheckHardwareSupport ( CpuFeatures feature ) : bool

CheckRange ( InputArray src, bool quiet = true ) : bool

checks that each matrix element is within the specified range.

CheckRange ( InputArray src, bool quiet, System.Point &pos, double minVal = double.MinValue, double maxVal = double.MaxValue ) : bool

checks that each matrix element is within the specified range.

Circle ( OpenCvSharp.InputOutputArray img, System.Point center, int radius, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws a circle

Circle ( OpenCvSharp.InputOutputArray img, int centerX, int centerY, int radius, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws a circle

ClipLine ( Rect imgRect, System.Point &pt1, System.Point &pt2 ) : bool

Clips the line against the image rectangle

ClipLine ( Size imgSize, System.Point &pt1, System.Point &pt2 ) : bool

Clips the line against the image rectangle

ColorChange ( InputArray src, InputArray mask, OutputArray dst, float redMul = 1.0f, float greenMul = 1.0f, float blueMul = 1.0f ) : void

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

Compare ( InputArray src1, InputArray src2, OutputArray dst, CmpTypes cmpop ) : void

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

CompareHist ( InputArray h1, InputArray h2, HistCompMethods method ) : double

compares two histograms stored in dense arrays

CompleteSymm ( OpenCvSharp.InputOutputArray mtx, bool lowerToUpper = false ) : void

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

ComposeRT ( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1 = null, OutputArray dr3dt1 = null, OutputArray dr3dr2 = null, OutputArray dr3dt2 = null, OutputArray dt3dr1 = null, OutputArray dt3dt1 = null, OutputArray dt3dr2 = null, OutputArray dt3dt2 = null ) : void

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

ComposeRT ( double rvec1, double tvec1, double rvec2, double tvec2, double &rvec3, double &tvec3 ) : void

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

ComposeRT ( double rvec1, double tvec1, double rvec2, double tvec2, double &rvec3, double &tvec3, double &dr3dr1, double &dr3dt1, double &dr3dr2, double &dr3dt2, double &dt3dr1, double &dt3dt1, double &dt3dr2, double &dt3dt2 ) : void

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

ComputeCorrespondEpilines ( IEnumerable points, int whichImage, double F ) : Point3f[]

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

ComputeCorrespondEpilines ( IEnumerable points, int whichImage, double F ) : Point3f[]

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

ComputeCorrespondEpilines ( InputArray points, int whichImage, InputArray F, OutputArray lines ) : void

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

ComputeRecallPrecisionCurve ( OpenCvSharp.DMatch matches1to2, byte correctMatches1to2Mask ) : Point2f[]

ConnectedComponents ( InputArray image, OutputArray labels, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : int

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

ConnectedComponents ( InputArray image, OutputArray labels, PixelConnectivity connectivity, MatType ltype ) : int

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

ConnectedComponents ( InputArray image, int &labels, PixelConnectivity connectivity ) : int

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

ConnectedComponentsEx ( InputArray image, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : ConnectedComponents

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

ConnectedComponentsWithStats ( InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : int

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

ConnectedComponentsWithStats ( InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, PixelConnectivity connectivity, MatType ltype ) : int

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

ContourArea ( IEnumerable contour, bool oriented = false ) : double

Calculates the contour area

ContourArea ( IEnumerable contour, bool oriented = false ) : double

Calculates the contour area

ContourArea ( InputArray contour, bool oriented = false ) : double

Calculates the contour area

ConvertImage ( OpenCvSharp.Mat src, OpenCvSharp.Mat dst, ConvertImageModes flags = ConvertImageModes.None ) : void

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

ConvertMaps ( InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, MatType dstmap1Type, bool nnInterpolation = false ) : void

ConvertPointsFromHomogeneous ( IEnumerable src ) : Vec2f[]

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

ConvertPointsFromHomogeneous ( IEnumerable src ) : Vec3f[]

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

ConvertPointsFromHomogeneous ( InputArray src, OutputArray dst ) : void

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

ConvertPointsHomogeneous ( InputArray src, OutputArray dst ) : void

Converts points to/from homogeneous coordinates.

ConvertPointsToHomogeneous ( IEnumerable src ) : Vec3f[]

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

ConvertPointsToHomogeneous ( IEnumerable src ) : Vec4f[]

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

ConvertPointsToHomogeneous ( InputArray src, OutputArray dst ) : void

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

ConvertScaleAbs ( InputArray src, OutputArray dst, double alpha = 1, double beta ) : void

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

ConvexHull ( IEnumerable points, bool clockwise = false ) : Point2f[]

Computes convex hull for a set of 2D points.

ConvexHull ( IEnumerable points, bool clockwise = false ) : System.Point[]

Computes convex hull for a set of 2D points.

ConvexHull ( InputArray points, OutputArray hull, bool clockwise = false, bool returnPoints = true ) : void

Computes convex hull for a set of 2D points.

ConvexHullIndices ( IEnumerable points, bool clockwise = false ) : int[]

Computes convex hull for a set of 2D points.

ConvexHullIndices ( IEnumerable points, bool clockwise = false ) : int[]

Computes convex hull for a set of 2D points.

ConvexityDefects ( IEnumerable contour, IEnumerable convexHull ) : Vec4i[]

Computes the contour convexity defects

ConvexityDefects ( IEnumerable contour, IEnumerable convexHull ) : Vec4i[]

Computes the contour convexity defects

ConvexityDefects ( InputArray contour, InputArray convexHull, OutputArray convexityDefects ) : void

Computes the contour convexity defects

CopyMakeBorder ( InputArray src, OutputArray dst, int top, int bottom, int left, int right, BorderTypes borderType, Scalar value = null ) : void

Forms a border around the image

CornerEigenValsAndVecs ( InputArray src, OutputArray dst, int blockSize, int ksize, BorderTypes borderType = BorderTypes.Default ) : void

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

CornerSubPix ( InputArray image, IEnumerable inputCorners, Size winSize, Size zeroZone, OpenCvSharp.TermCriteria criteria ) : Point2f[]

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

CorrectMatches ( InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2 ) : void

Refines coordinates of corresponding points.

CorrectMatches ( double F, IEnumerable points1, IEnumerable points2, Point2d &newPoints1, Point2d &newPoints2 ) : void

Refines coordinates of corresponding points.

CountNonZero ( InputArray mtx ) : int

computes the number of nonzero array elements

CreateCLAHE ( double clipLimit = 40.0, Size tileGridSize = null ) : CLAHE

Creates a predefined CLAHE object

CreateHanningWindow ( OpenCvSharp.InputOutputArray dst, Size winSize, MatType type ) : void

Computes a Hanning window coefficients in two dimensions.

CreateOptFlow_DualTVL1 ( ) : OpenCvSharp.DenseOpticalFlow

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

CubeRoot ( float val ) : float

computes cube root of the argument

CvtColor ( InputArray src, OutputArray dst, ColorConversionCodes code, int dstCn ) : void

Converts image from one color space to another

Dct ( InputArray src, OutputArray dst, DctFlags flags = DctFlags.None ) : void

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

Decolor ( InputArray src, OutputArray grayscale, OutputArray colorBoost ) : void

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

DecomposeProjectionMatrix ( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX = null, OutputArray rotMatrixY = null, OutputArray rotMatrixZ = null, OutputArray eulerAngles = null ) : void

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

DecomposeProjectionMatrix ( double projMatrix, double &cameraMatrix, double &rotMatrix, double &transVect ) : void

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

DecomposeProjectionMatrix ( double projMatrix, double &cameraMatrix, double &rotMatrix, double &transVect, double &rotMatrixX, double &rotMatrixY, double &rotMatrixZ, double &eulerAngles ) : void

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

DenoiseTVL1 ( IEnumerable observations, OpenCvSharp.Mat result, double lambda = 1.0, int niters = 30 ) : void

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

DestroyAllWindows ( ) : void

DestroyWindow ( string winName ) : void

DetailEnhance ( InputArray src, OutputArray dst, float sigmaS = 10, float sigmaR = 0.15f ) : void

This filter enhances the details of a particular image.

Determinant ( InputArray mtx ) : double

computes determinant of a square matrix

Dft ( InputArray src, OutputArray dst, DftFlags flags = DftFlags.None, int nonzeroRows ) : void

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

Dilate ( InputArray src, OutputArray dst, InputArray element, System.Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void

Dilates an image by using a specific structuring element.

DistanceTransform ( InputArray src, OutputArray dst, DistanceTypes distanceType, DistanceMaskSize maskSize ) : void

computes the distance transform map

DistanceTransformWithLabels ( InputArray src, OutputArray dst, OutputArray labels, DistanceTypes distanceType, DistanceMaskSize maskSize, DistanceTransformLabelTypes labelType = DistanceTransformLabelTypes.CComp ) : void

builds the discrete Voronoi diagram

Divide ( InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1 ) : void

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

Divide ( double scale, InputArray src2, OutputArray dst, int dtype = -1 ) : void

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

DrawChessboardCorners ( OpenCvSharp.InputOutputArray image, Size patternSize, IEnumerable corners, bool patternWasFound ) : void

Renders the detected chessboard corners.

DrawChessboardCorners ( OpenCvSharp.InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound ) : void

Renders the detected chessboard corners.

DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable contours, int contourIdx, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, OpenCvSharp.Mat hierarchy = null, int maxLevel = Int32.MaxValue, System.Point offset = null ) : void

draws contours in the image

DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable contours, int contourIdx, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, IEnumerable hierarchy = null, int maxLevel = Int32.MaxValue, System.Point offset = null ) : void

draws contours in the image

DrawKeypoints ( OpenCvSharp.Mat image, IEnumerable keypoints, OpenCvSharp.Mat outImage, Scalar color = null, DrawMatchesFlags flags = DrawMatchesFlags.Default ) : void

Draw keypoints.

DrawMatches ( OpenCvSharp.Mat img1, IEnumerable keypoints1, OpenCvSharp.Mat img2, IEnumerable keypoints2, IEnumerable matches1To2, OpenCvSharp.Mat outImg, Scalar matchColor = null, Scalar singlePointColor = null, IEnumerable matchesMask = null, DrawMatchesFlags flags = DrawMatchesFlags.Default ) : void

Draws matches of keypints from two images on output image.

EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType ) : float

EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost ) : float

EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost, float &lowerBound ) : float

EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost, float &lowerBound, OutputArray flow ) : float

EdgePreservingFilter ( InputArray src, OutputArray dst, EdgePreservingMethods flags = EdgePreservingMethods.RecursFilter, float sigmaS = 60, float sigmaR = 0.4f ) : void

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

Eigen ( InputArray src, OutputArray eigenvalues, OutputArray eigenvectors ) : bool

Computes eigenvalues and eigenvectors of a symmetric matrix.

Ellipse ( OpenCvSharp.InputOutputArray img, System.Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws simple or thick elliptic arc or fills ellipse sector

Ellipse ( OpenCvSharp.InputOutputArray img, OpenCvSharp.RotatedRect box, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8 ) : void

Draws simple or thick elliptic arc or fills ellipse sector

Ellipse2Poly ( System.Point center, Size axes, int angle, int arcStart, int arcEnd, int delta ) : System.Point[]

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

EqualizeHist ( InputArray src, OutputArray dst ) : void

normalizes the grayscale image brightness and contrast by normalizing its histogram

Erode ( InputArray src, OutputArray dst, InputArray element, System.Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void

Erodes an image by using a specific structuring element.

EstimateAffine3D ( InputArray src, InputArray dst, OutputArray outVal, OutputArray inliers, double ransacThreshold = 3, double confidence = 0.99 ) : int

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

EstimateRigidTransform ( InputArray src, InputArray dst, bool fullAffine ) : OpenCvSharp.Mat

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

EvaluateFeatureDetector ( OpenCvSharp.Mat img1, OpenCvSharp.Mat img2, OpenCvSharp.Mat H1to2, KeyPoint &keypoints1, KeyPoint &keypoints2, float &repeatability, int &correspCount ) : void

Exp ( InputArray src, OutputArray dst ) : void

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

ExtractChannel ( InputArray src, OutputArray dst, int coi ) : void

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

FAST ( InputArray image, int threshold, bool nonmaxSupression = true ) : KeyPoint[]

Detects corners using the FAST algorithm

FAST ( InputArray image, int threshold, bool nonmaxSupression, FASTType type ) : KeyPoint[]

Detects corners using the FAST algorithm

FastAtan2 ( float y, float x ) : float

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

FastFree ( IntPtr ptr ) : void

FastMalloc ( long bufSize ) : IntPtr

FastNlMeansDenoising ( InputArray src, OutputArray dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

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

FastNlMeansDenoisingColored ( InputArray src, OutputArray dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

Modification of fastNlMeansDenoising function for colored images

FastNlMeansDenoisingColoredMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

Modification of fastNlMeansDenoisingMulti function for colored images sequences

FastNlMeansDenoisingColoredMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

Modification of fastNlMeansDenoisingMulti function for colored images sequences

FastNlMeansDenoisingMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

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.

FastNlMeansDenoisingMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void

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.

FillConvexPoly ( OpenCvSharp.InputOutputArray img, InputArray pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift ) : void

Fills a convex polygon.

FillConvexPoly ( OpenCvSharp.Mat img, IEnumerable pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift ) : void

Fills a convex polygon.

FillPoly ( OpenCvSharp.InputOutputArray img, InputArray pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift, System.Point offset = null ) : void

Fills the area bounded by one or more polygons

FillPoly ( OpenCvSharp.Mat img, IEnumerable pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift, System.Point offset = null ) : void

Fills the area bounded by one or more polygons

Filter2D ( InputArray src, OutputArray dst, MatType ddepth, InputArray kernel, System.Point anchor = null, double delta, BorderTypes borderType = BorderTypes.Default ) : void

Convolves an image with the kernel

FilterSpeckles ( OpenCvSharp.InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, OpenCvSharp.InputOutputArray buf = null ) : void

filters off speckles (small regions of incorrectly computed disparity)

Find4QuadCornerSubpix ( InputArray img, OpenCvSharp.InputOutputArray corners, Size regionSize ) : bool

finds subpixel-accurate positions of the chessboard corners

Find4QuadCornerSubpix ( InputArray img, [ corners, Size regionSize ) : bool

finds subpixel-accurate positions of the chessboard corners

FindChessboardCorners ( InputArray image, Size patternSize, OutputArray corners, ChessboardFlags flags = ChessboardFlags.AdaptiveThresh|ChessboardFlags.NormalizeImage ) : bool

Finds the positions of internal corners of the chessboard.

FindChessboardCorners ( InputArray image, Size patternSize, Point2f &corners, ChessboardFlags flags = ChessboardFlags.AdaptiveThresh|ChessboardFlags.NormalizeImage ) : bool

Finds the positions of internal corners of the chessboard.

FindCirclesGrid ( InputArray image, Size patternSize, OutputArray centers, FindCirclesGridFlags flags = FindCirclesGridFlags.SymmetricGrid, FeatureDetector blobDetector = null ) : bool

Finds centers in the grid of circles.

FindCirclesGrid ( InputArray image, Size patternSize, Point2f &centers, FindCirclesGridFlags flags = FindCirclesGridFlags.SymmetricGrid, FeatureDetector blobDetector = null ) : bool

Finds centers in the grid of circles.

FindContours ( InputOutputArray image, Mat &contours, OutputArray hierarchy, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : void

Finds contours in a binary image.

FindContours ( InputOutputArray image, Point &contours, HierarchyIndex &hierarchy, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : void

Finds contours in a binary image.

FindContoursAsArray ( InputOutputArray image, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : Point[][]

Finds contours in a binary image.

FindContoursAsMat ( InputOutputArray image, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : MatOfPoint[]

Finds contours in a binary image.

FindFundamentalMat ( IEnumerable points1, IEnumerable points2, FundamentalMatMethod method = FundamentalMatMethod.Ransac, double param1 = 3.0, double param2 = 0.99, OutputArray mask = null ) : Mat

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

FindFundamentalMat ( InputArray points1, InputArray points2, FundamentalMatMethod method = FundamentalMatMethod.Ransac, double param1 = 3.0, double param2 = 0.99, OutputArray mask = null ) : Mat

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

FindHomography ( IEnumerable srcPoints, IEnumerable dstPoints, HomographyMethods method = HomographyMethods.None, double ransacReprojThreshold = 3, OutputArray mask = null ) : Mat

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

FindHomography ( InputArray srcPoints, InputArray dstPoints, HomographyMethods method = HomographyMethods.None, double ransacReprojThreshold = 3, OutputArray mask = null ) : Mat

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

FindNonZero ( InputArray src, OutputArray idx ) : void

returns the list of locations of non-zero pixels

FitEllipse ( IEnumerable points ) : RotatedRect

Fits ellipse to the set of 2D points.

FitEllipse ( IEnumerable points ) : RotatedRect

Fits ellipse to the set of 2D points.

FitEllipse ( InputArray points ) : RotatedRect

Fits ellipse to the set of 2D points.

FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line2D

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

FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line2D

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

FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line3D

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

FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line3D

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

FitLine ( InputArray points, OutputArray line, DistanceTypes distType, double param, double reps, double aeps ) : void

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

Flip ( InputArray src, OutputArray dst, FlipMode flipCode ) : void

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

FloodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal ) : int

Fills a connected component with the given color.

FloodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect &rect, Scalar loDiff = null, Scalar upDiff = null, FloodFillFlags flags = FloodFillFlags.Link4 ) : int

Fills a connected component with the given color.

FloodFill ( InputOutputArray image, Point seedPoint, Scalar newVal ) : int

Fills a connected component with the given color.

FloodFill ( InputOutputArray image, Point seedPoint, Scalar newVal, Rect &rect, Scalar loDiff = null, Scalar upDiff = null, FloodFillFlags flags = FloodFillFlags.Link4 ) : int

Fills a connected component with the given color.

GaussianBlur ( InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY, BorderTypes borderType = BorderTypes.Default ) : void

Blurs an image using a Gaussian filter.

Gemm ( InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, GemmFlags flags = GemmFlags.None ) : void

implements generalized matrix product algorithm GEMM from BLAS

GetAffineTransform ( IEnumerable src, IEnumerable dst ) : Mat

GetAffineTransform ( InputArray src, InputArray dst ) : Mat

GetBuildInformation ( ) : string

GetCpuTickCount ( ) : long

GetDefaultNewCameraMatrix ( InputArray cameraMatrix, Size imgSize = null, bool centerPrincipalPoint = false ) : Mat

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

GetDerivKernels ( OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize = false, MatType ktype = null ) : void

Returns filter coefficients for computing spatial image derivatives.

GetGaborKernel ( Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype ) : Mat

GetGaussianKernel ( int ksize, double sigma, MatType ktype = null ) : Mat

Returns Gaussian filter coefficients.

GetNearestPoint ( IEnumerable recallPrecisionCurve, float lPrecision ) : int

GetNumThreads ( ) : int

GetNumberOfCpus ( ) : int

GetOptimalDFTSize ( int vecsize ) : int

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

GetOptimalNewCameraMatrix ( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect &validPixROI, bool centerPrincipalPoint = false ) : Mat

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

GetOptimalNewCameraMatrix ( double cameraMatrix, double distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect &validPixROI, bool centerPrincipalPoint = false ) : ].double[

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

GetPerspectiveTransform ( IEnumerable src, IEnumerable dst ) : Mat

GetPerspectiveTransform ( InputArray src, InputArray dst ) : Mat

GetRecall ( IEnumerable recallPrecisionCurve, float lPrecision ) : float

GetRectSubPix ( InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType = -1 ) : void

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

GetRotationMatrix2D ( Point2f center, double angle, double scale ) : Mat

GetStructuringElement ( MorphShapes shape, Size ksize ) : Mat

GetStructuringElement ( MorphShapes shape, Size ksize, Point anchor ) : Mat

GetTextSize ( string text, HersheyFonts fontFace, double fontScale, int thickness, int &baseLine ) : Size

returns bounding box of the text string

GetThreadNum ( ) : int

GetTickCount ( ) : long

GetTickFrequency ( ) : double

GetValidDisparityROI ( Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize ) : Rect

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

GetWindowProperty ( string winName, WindowProperty propId ) : double

Provides parameters of a window.

GoodFeaturesToTrack ( InputArray src, int maxCorners, double qualityLevel, double minDistance, InputArray mask, int blockSize, bool useHarrisDetector, double k ) : Point2f[]

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

GrabCut ( InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, GrabCutModes mode ) : void

Segments the image using GrabCut algorithm

HConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void

HConcat ( Mat src, OutputArray dst ) : void

HaveImageReader ( string fileName ) : bool

HaveImageWriter ( string fileName ) : bool

HoughCircles ( InputArray image, HoughMethods method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius, int maxRadius ) : CircleSegment[]

Finds circles in a grayscale image using a Hough transform.

HoughLines ( InputArray image, double rho, double theta, int threshold, double srn, double stn ) : LineSegmentPolar[]

Finds lines in a binary image using standard Hough transform.

HoughLinesP ( InputArray image, double rho, double theta, int threshold, double minLineLength, double maxLineGap ) : LineSegmentPoint[]

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

Idct ( InputArray src, OutputArray dst, DctFlags flags = DctFlags.None ) : void

Performs inverse 1D or 2D Discrete Cosine Transformation

Idft ( InputArray src, OutputArray dst, DftFlags flags = DftFlags.None, int nonzeroRows ) : void

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

IlluminationChange ( InputArray src, InputArray mask, OutputArray dst, float alpha = 0.2f, float beta = 0.4f ) : void

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

This is useful to highlight under-exposed foreground objects or to reduce specular reflections.

ImDecode ( InputArray buf, ImreadModes flags ) : Mat

Reads image from the specified buffer in memory.

ImDecode ( Mat buf, ImreadModes flags ) : Mat

Reads image from the specified buffer in memory.

ImDecode ( byte buf, ImreadModes flags ) : Mat

Reads image from the specified buffer in memory.

ImEncode ( string ext, InputArray img, byte &buf, int prms = null ) : bool

Compresses the image and stores it in the memory buffer

ImEncode ( string ext, InputArray img, byte &buf ) : void

Compresses the image and stores it in the memory buffer

ImRead ( string fileName, ImreadModes flags = ImreadModes.Color ) : Mat

Loads an image from a file.

ImReadMulti ( string filename, Mat &mats, ImreadModes flags = ImreadModes.AnyColor ) : bool

Loads a multi-page image from a file.

ImShow ( string winname, Mat mat ) : void

Displays the image in the specified window

ImWrite ( string fileName, Mat img ) : bool

Saves an image to a specified file.

ImWrite ( string fileName, Mat img, int prms = null ) : bool

Saves an image to a specified file.

InRange ( InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst ) : void

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

InRange ( InputArray src, Scalar lowerb, Scalar upperb, OutputArray dst ) : void

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

InitCameraMatrix2D ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double aspectRatio = 1.0 ) : Mat

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

InitCameraMatrix2D ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double aspectRatio = 1.0 ) : Mat

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

InitUndistortRectifyMap ( InputArray cameraMatrix, InputArray distCoeffs, InputArray r, InputArray newCameraMatrix, Size size, MatType m1Type, OutputArray map1, OutputArray map2 ) : void

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

InitWideAngleProjMap ( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, MatType m1Type, OutputArray map1, OutputArray map2, ProjectionType projType, double alpha ) : float

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

Inpaint ( InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, InpaintMethod flags ) : void

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

InsertChannel ( InputArray src, InputOutputArray dst, int coi ) : void

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

Integral ( InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth = -1 ) : void

Integral ( InputArray src, OutputArray sum, OutputArray sqsum, int sdepth = -1 ) : void

Integral ( InputArray src, OutputArray sum, int sdepth = -1 ) : void

IntersectConvexConvex ( IEnumerable p1, IEnumerable p2, Point2f &p12, bool handleNested = true ) : float

finds intersection of two convex polygons

IntersectConvexConvex ( IEnumerable p1, IEnumerable p2, Point &p12, bool handleNested = true ) : float

finds intersection of two convex polygons

IntersectConvexConvex ( InputArray p1, InputArray p2, OutputArray p12, bool handleNested = true ) : float

finds intersection of two convex polygons

Invert ( InputArray src, OutputArray dst, DecompTypes flags = DecompTypes.LU ) : double

computes inverse or pseudo-inverse matrix

InvertAffineTransform ( InputArray m, OutputArray im ) : void

Inverts an affine transformation.

IsContourConvex ( IEnumerable contour ) : bool

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

IsContourConvex ( IEnumerable contour ) : bool

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

IsContourConvex ( InputArray contour ) : bool

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

Kmeans ( InputArray data, int k, InputOutputArray bestLabels, TermCriteria criteria, int attempts, KMeansFlags flags, OutputArray centers = null ) : double

clusters the input data using k-Means algorithm

LUT ( InputArray src, InputArray lut, OutputArray dst, int interpolation ) : void

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

LUT ( InputArray src, byte lut, OutputArray dst, int interpolation ) : void

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

Laplacian ( InputArray src, OutputArray dst, MatType ddepth, int ksize = 1, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void

Calculates the Laplacian of an image

Line ( InputOutputArray img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws a line segment connecting two points

Line ( InputOutputArray img, int pt1X, int pt1Y, int pt2X, int pt2Y, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws a line segment connecting two points

LinearPolar ( InputArray src, OutputArray dst, Point2f center, double maxRadius, InterpolationFlags flags ) : void

Remaps an image to polar space.

Log ( InputArray src, OutputArray dst ) : void

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

LogPolar ( InputArray src, OutputArray dst, Point2f center, double m, InterpolationFlags flags ) : void

Remaps an image to log-polar space.

Magnitude ( InputArray x, InputArray y, OutputArray magnitude ) : void

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

Mahalanobis ( InputArray v1, InputArray v2, InputArray icovar ) : double

Mahalonobis ( InputArray v1, InputArray v2, InputArray icovar ) : double

computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix

MatMulDeriv ( InputArray a, InputArray b, OutputArray dABdA, OutputArray dABdB ) : void

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

MatchShapes ( IEnumerable contour1, IEnumerable contour2, ShapeMatchModes method, double parameter ) : double

matches two contours using one of the available algorithms

MatchShapes ( InputArray contour1, InputArray contour2, ShapeMatchModes method, double parameter ) : double

matches two contours using one of the available algorithms

MatchTemplate ( InputArray image, InputArray templ, OutputArray result, TemplateMatchModes method, InputArray mask = null ) : void

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

Max ( InputArray src1, InputArray src2, OutputArray dst ) : void

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

Max ( Mat src1, Mat src2, Mat dst ) : void

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

Max ( Mat src1, double src2, Mat dst ) : void

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

Mean ( InputArray src, InputArray mask = null ) : Scalar

computes mean value of selected array elements

MeanShift ( InputArray probImage, Rect &window, TermCriteria criteria ) : int

Finds an object on a back projection image.

MeanStdDev ( InputArray src, OutputArray mean, OutputArray stddev, InputArray mask = null ) : void

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

MeanStdDev ( InputArray src, Scalar &mean, Scalar &stddev, InputArray mask = null ) : void

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

MedianBlur ( InputArray src, OutputArray dst, int ksize ) : void

Smoothes image using median filter

Merge ( Mat mv, Mat dst ) : void

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

Min ( InputArray src1, InputArray src2, OutputArray dst ) : void

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

Min ( Mat src1, Mat src2, Mat dst ) : void

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

Min ( Mat src1, double src2, Mat dst ) : void

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

MinAreaRect ( IEnumerable points ) : RotatedRect

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

MinAreaRect ( IEnumerable points ) : RotatedRect

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

MinAreaRect ( InputArray points ) : RotatedRect

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

MinEnclosingCircle ( IEnumerable points, Point2f &center, float &radius ) : void

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

MinEnclosingCircle ( IEnumerable points, Point2f &center, float &radius ) : void

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

MinEnclosingCircle ( InputArray points, Point2f &center, float &radius ) : void

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

MinMaxIdx ( InputArray src, double &minVal, double &maxVal ) : void

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

MinMaxIdx ( InputArray src, double &minVal, double &maxVal, int &minIdx, int &maxIdx, InputArray mask = null ) : void

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

MinMaxIdx ( InputArray src, int &minIdx, int &maxIdx ) : void

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

MinMaxLoc ( InputArray src, Point &minLoc, Point &maxLoc ) : void

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

MinMaxLoc ( InputArray src, double &minVal, double &maxVal ) : void

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

MinMaxLoc ( InputArray src, double &minVal, double &maxVal, Point &minLoc, Point &maxLoc, InputArray mask = null ) : void

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

MixChannels ( Mat src, Mat dst, int fromTo ) : void

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

Moments ( IEnumerable array, bool binaryImage = false ) : Moments

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

Moments ( IEnumerable array, bool binaryImage = false ) : Moments

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

Moments ( InputArray array, bool binaryImage = false ) : Moments

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

Moments ( byte array, bool binaryImage = false ) : Moments

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

Moments ( float array, bool binaryImage = false ) : Moments

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

MorphologyDefaultBorderValue ( ) : Scalar

Default borderValue for Dilate/Erode

MorphologyEx ( InputArray src, OutputArray dst, MorphTypes op, InputArray element, Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void

Performs advanced morphological transformations

MoveWindow ( string winName, int x, int y ) : void

Moves window to the specified position

MulSpectrums ( InputArray a, InputArray b, OutputArray c, DftFlags flags, bool conjB = false ) : void

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

MulTransposed ( InputArray src, OutputArray dst, bool aTa, InputArray delta = null, double scale = 1, int dtype = -1 ) : void

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

Multiply ( InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1 ) : void

Calculates the per-element scaled product of two arrays

NamedWindow ( string winname ) : void

Creates a window.

NamedWindow ( string winname, WindowMode flags ) : void

Creates a window.

Norm ( InputArray src1, InputArray src2, NormTypes normType = NormTypes.L2, InputArray mask = null ) : double

computes norm of selected part of the difference between two arrays

Norm ( InputArray src1, NormTypes normType = NormTypes.L2, InputArray mask = null ) : double

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

Normalize ( InputArray src, InputOutputArray dst, double alpha = 1, double beta, NormTypes normType = NormTypes.L2, int dtype = -1, InputArray mask = null ) : void

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

PCABackProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void

PCACompute ( InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents ) : void

PCA of the supplied dataset.

PCAComputeVar ( InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance ) : void

PCAProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void

PSNR ( InputArray src1, InputArray src2 ) : double

PatchNaNs ( InputOutputArray a, double val ) : void

converts NaN's to the given number

PencilSketch ( InputArray src, OutputArray dst1, OutputArray dst2, float sigmaS = 60, float sigmaR = 0.07f, float shadeFactor = 0.02f ) : void

Pencil-like non-photorealistic line drawing

PerspectiveTransform ( IEnumerable src, Mat m ) : Point2d[]

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

PerspectiveTransform ( IEnumerable src, Mat m ) : Point2f[]

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

PerspectiveTransform ( IEnumerable src, Mat m ) : Point3d[]

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

PerspectiveTransform ( IEnumerable src, Mat m ) : Point3f[]

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

PerspectiveTransform ( InputArray src, OutputArray dst, InputArray m ) : void

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

Phase ( InputArray x, InputArray y, OutputArray angle, bool angleInDegrees = false ) : void

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

PhaseCorrelate ( InputArray src1, InputArray src2, InputArray window = null ) : Point2d

PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window ) : Point2d

PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window, double &response ) : Point2d

PointPolygonTest ( IEnumerable contour, Point2f pt, bool measureDist ) : double

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

PointPolygonTest ( IEnumerable contour, Point2f pt, bool measureDist ) : double

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

PointPolygonTest ( InputArray contour, Point2f pt, bool measureDist ) : double

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

PolarToCart ( InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees = false ) : void

converts polar coordinates to Cartesian

Polylines ( InputOutputArray img, InputArray pts, bool isClosed, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

draws one or more polygonal curves

Polylines ( Mat img, IEnumerable pts, bool isClosed, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

draws one or more polygonal curves

Pow ( InputArray src, double power, OutputArray dst ) : void

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

PreCornerDetect ( InputArray src, OutputArray dst, int ksize, BorderTypes borderType = BorderTypes.Default ) : void

computes another complex cornerness criteria at each pixel

ProjectPoints ( IEnumerable objectPoints, double rvec, double tvec, double cameraMatrix, double distCoeffs, Point2f &imagePoints, double &jacobian, double aspectRatio ) : void

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

ProjectPoints ( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian = null, double aspectRatio ) : void

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

PutText ( InputOutputArray img, string text, Point org, HersheyFonts fontFace, double fontScale, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, bool bottomLeftOrigin = false ) : void

renders text string in the image

PyrDown ( InputArray src, OutputArray dst, Size dstSize = null, BorderTypes borderType = BorderTypes.Default ) : void

Blurs an image and downsamples it.

PyrMeanShiftFiltering ( InputArray src, OutputArray dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = null ) : void

Performs initial step of meanshift segmentation of an image.

PyrUp ( InputArray src, OutputArray dst, Size dstSize = null, BorderTypes borderType = BorderTypes.Default ) : void

Upsamples an image and then blurs it.

RQDecomp3x3 ( InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray qx = null, OutputArray qy = null, OutputArray qz = null ) : Vec3d

Computes RQ decomposition of 3x3 matrix

RQDecomp3x3 ( double src, double &mtxR, double &mtxQ ) : Vec3d

Computes RQ decomposition of 3x3 matrix

RQDecomp3x3 ( double src, double &mtxR, double &mtxQ, double &qx, double &qy, double &qz ) : Vec3d

Computes RQ decomposition of 3x3 matrix

RandShuffle ( InputOutputArray dst, double iterFactor, RNG rng = null ) : void

shuffles the input array elements

Randn ( InputOutputArray dst, InputArray mean, InputArray stddev ) : void

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

Randn ( InputOutputArray dst, Scalar mean, Scalar stddev ) : void

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

Randu ( InputOutputArray dst, InputArray low, InputArray high ) : void

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

Randu ( InputOutputArray dst, Scalar low, Scalar high ) : void

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

ReadDMatches ( FileNode node ) : DMatch[]

ReadDouble ( FileNode node, double defaultValue = default(double) ) : double

ReadFloat ( FileNode node, float defaultValue = default(float) ) : float

ReadInt ( FileNode node, int defaultValue = default(int) ) : int

ReadKeyPoints ( FileNode node ) : KeyPoint[]

ReadMat ( FileNode node, Mat defaultMat = null ) : Mat

ReadSparseMat ( FileNode node, SparseMat defaultMat = null ) : SparseMat

ReadString ( FileNode node, string defaultValue = default(string) ) : string

Rectangle ( InputOutputArray img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws simple, thick or filled rectangle

Rectangle ( InputOutputArray img, Rect rect, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws simple, thick or filled rectangle

Rectangle ( Mat img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws simple, thick or filled rectangle

Rectangle ( Mat img, Rect rect, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void

Draws simple, thick or filled rectangle

Rectify3Collinear ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, IEnumerable imgpt1, IEnumerable imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, Rect &roi1, Rect &roi2, StereoRectificationFlags flags ) : float

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

Reduce ( InputArray src, OutputArray dst, ReduceDimension dim, ReduceTypes rtype, int dtype ) : void

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

Remap ( InputArray src, OutputArray dst, InputArray map1, InputArray map2, InterpolationFlags interpolation = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void

Applies a generic geometrical transformation to an image.

Repeat ( Mat src, int ny, int nx ) : Mat

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

Repeat ( InputArray src, int ny, int nx, OutputArray dst ) : void

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

ReprojectImageTo3D ( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues = false, int ddepth = -1 ) : void

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

Resize ( InputArray src, OutputArray dst, Size dsize, double fx, double fy, InterpolationFlags interpolation = InterpolationFlags.Linear ) : void

Resizes an image.

ResizeWindow ( string winName, int width, int height ) : void

Resizes window to the specified size

Rodrigues ( InputArray src, OutputArray dst, OutputArray jacobian = null ) : void

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

Rodrigues ( double vector, double &matrix ) : void

converts rotation vector to rotation matrix using Rodrigues transformation

Rodrigues ( double vector, double &matrix, double &jacobian ) : void

converts rotation vector to rotation matrix using Rodrigues transformation

RotatedRectangleIntersection ( RotatedRect rect1, RotatedRect rect2, OutputArray intersectingRegion ) : RectanglesIntersectTypes

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

RotatedRectangleIntersection ( RotatedRect rect1, RotatedRect rect2, Point2f &intersectingRegion ) : RectanglesIntersectTypes

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

SVBackSubst ( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ) : void

performs back substitution for the previously computed SVD

SVDecomp ( InputArray src, OutputArray w, OutputArray u, OutputArray vt, SVD flags = SVD.Flags.None ) : void

computes SVD of src

ScaleAdd ( InputArray src1, double alpha, InputArray src2, OutputArray dst ) : void

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

Scharr ( InputArray src, OutputArray dst, MatType ddepth, int xorder, int yorder, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void

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

SeamlessClone ( InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, SeamlessCloneMethods flags ) : void

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

SegmentMotion ( InputArray mhi, OutputArray segmask, Rect &boundingRects, double timestamp, double segThresh ) : void

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

SepFilter2D ( InputArray src, OutputArray dst, MatType ddepth, InputArray kernelX, InputArray kernelY, Point anchor = null, double delta, BorderTypes borderType = BorderTypes.Default ) : void

Applies separable linear filter to an image

SetIdentity ( InputOutputArray mtx, Scalar s = null ) : void

initializes scaled identity matrix

SetMouseCallback ( string windowName, CvMouseCallback onMouse ) : void

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

SetNumThreads ( int nthreads ) : void

SetUseOptimized ( bool onoff ) : void

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.

SetWindowProperty ( string winName, WindowProperty propId, double propValue ) : void

Changes parameters of a window dynamically.

SetWindowTitle ( string winname, string title ) : void

Updates window title

Sobel ( InputArray src, OutputArray dst, MatType ddepth, int xorder, int yorder, int ksize = 3, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void

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

Solve ( InputArray src1, InputArray src2, OutputArray dst, DecompTypes flags = DecompTypes.LU ) : bool

solves linear system or a least-square problem

SolveCubic ( InputArray coeffs, OutputArray roots ) : int

finds real roots of a cubic polynomial

SolvePnP ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec, bool useExtrinsicGuess = false, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void

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

SolvePnP ( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess = false, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void

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

SolvePnPRansac ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec ) : void

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

SolvePnPRansac ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec, int &inliers, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0f, double confidence = 0.99, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void

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

SolvePnPRansac ( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0f, double confidence = 0.99, OutputArray inliers = null, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void

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

SolvePoly ( InputArray coeffs, OutputArray roots, int maxIters = 300 ) : double

finds real and complex roots of a polynomial

Sort ( InputArray src, OutputArray dst, SortFlags flags ) : void

sorts independently each matrix row or each matrix column

SortIdx ( InputArray src, OutputArray dst, SortFlags flags ) : void

sorts independently each matrix row or each matrix column

Split ( Mat src ) : Mat[]

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

Split ( Mat src, Mat &mv ) : void

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

Sqrt ( InputArray src, OutputArray dst ) : void

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

StartWindowThread ( ) : int

StereoCalibrate ( IEnumerable objectPoints, IEnumerable imagePoints1, IEnumerable imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, CalibrationFlags flags = CalibrationFlags.FixIntrinsic, TermCriteria criteria = null ) : double

finds intrinsic and extrinsic parameters of a stereo camera

StereoCalibrate ( IEnumerable objectPoints, IEnumerable imagePoints1, IEnumerable imagePoints2, double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, CalibrationFlags flags = CalibrationFlags.FixIntrinsic, TermCriteria criteria = null ) : double

finds intrinsic and extrinsic parameters of a stereo camera

StereoRectify ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, StereoRectificationFlags flags = StereoRectificationFlags.ZeroDisparity, double alpha = -1, Size newImageSize = null ) : void

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

StereoRectify ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, StereoRectificationFlags flags, double alpha, Size newImageSize, Rect &validPixROI1, Rect &validPixROI2 ) : void

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

StereoRectify ( double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, double R, double T, double &R1, double &R2, double &P1, double &P2, double &Q, StereoRectificationFlags flags = StereoRectificationFlags.ZeroDisparity, double alpha = -1, Size newImageSize = null ) : void

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

StereoRectify ( double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, double R, double T, double &R1, double &R2, double &P1, double &P2, double &Q, StereoRectificationFlags flags, double alpha, Size newImageSize, Rect &validPixROI1, Rect &validPixROI2 ) : void

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

StereoRectifyUncalibrated ( IEnumerable points1, IEnumerable points2, double F, Size imgSize, double &H1, double &H2, double threshold = 5 ) : bool

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

StereoRectifyUncalibrated ( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold = 5 ) : bool

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

Stylization ( InputArray src, OutputArray dst, float sigmaS = 60, float sigmaR = 0.45f ) : void

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

Subtract ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null, int dtype = -1 ) : void

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

Sum ( InputArray src ) : Scalar

computes sum of array elements

TextureFlattening ( InputArray src, InputArray mask, OutputArray dst, float lowThreshold = 30, float highThreshold = 45, int kernelSize = 3 ) : void

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

TheRNG ( ) : RNG

returns the thread-local Random number generator

Threshold ( InputArray src, OutputArray dst, double thresh, double maxval, ThresholdTypes type ) : double

Applies a fixed-level threshold to each array element.

Trace ( InputArray mtx ) : Scalar

computes trace of a matrix

Transform ( InputArray src, OutputArray dst, InputArray m ) : void

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

Transpose ( InputArray src, OutputArray dst ) : void

transposes the matrix

TriangulatePoints ( double projMatr1, double projMatr2, IEnumerable projPoints1, IEnumerable projPoints2 ) : Vec4d[]

Reconstructs points by triangulation.

TriangulatePoints ( InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D ) : void

Reconstructs points by triangulation.

Undistort ( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix = null ) : void

corrects lens distortion for the given camera matrix and distortion coefficients

UndistortPoints ( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray r = null, InputArray p = null ) : void

Computes the ideal point coordinates from the observed point coordinates.

UpdateMotionHistory ( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration ) : void

Updates motion history image using the current silhouette

UseOptimized ( ) : bool

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

VConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void

VConcat ( Mat src, OutputArray dst ) : void

ValidateDisparity ( InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1 ) : void

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

WaitKey ( int delay ) : int

Waits for a pressed key.

WarpAffine ( InputArray src, OutputArray dst, InputArray m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void

Applies an affine transformation to an image.

WarpPerspective ( InputArray src, OutputArray dst, InputArray m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void

Applies a perspective transformation to an image.

WarpPerspective ( InputArray src, OutputArray dst, float m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void

Applies a perspective transformation to an image.

Watershed ( InputArray image, InputOutputArray markers ) : void

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

Write ( FileStorage fs, string name, IEnumerable value ) : void

Write ( FileStorage fs, string name, IEnumerable value ) : void

Write ( FileStorage fs, string name, Mat value ) : void

Write ( FileStorage fs, string name, SparseMat value ) : void

Write ( FileStorage fs, string name, double value ) : void

Write ( FileStorage fs, string name, float value ) : void

Write ( FileStorage fs, string name, int value ) : void

Write ( FileStorage fs, string name, string value ) : void

WriteScalar ( FileStorage fs, double value ) : void

WriteScalar ( FileStorage fs, float value ) : void

WriteScalar ( FileStorage fs, int value ) : void

WriteScalar ( FileStorage fs, string value ) : void

calcOpticalFlowSF ( Mat from, Mat to, Mat flow, int layers, int averagingBlockSize, int maxFlow, double sigmaDist, double sigmaColor, int postprocessWindow, double sigmaDistFix, double sigmaColorFix, double occThr, int upscaleAveragingRadius, double upscaleSigmaDist, double upscaleSigmaColor, double speedUpThr ) : void

computes dense optical flow using Simple Flow algorithm

Method Details

AGAST() public static method

Detects corners using the AGAST algorithm
public static AGAST ( InputArray image, int threshold, bool nonmaxSuppression, AGASTType type ) : KeyPoint[]
image InputArray grayscale image where keypoints (corners) are detected.
threshold int threshold on difference between intensity of the central pixel /// and pixels of a circle around this pixel.
nonmaxSuppression bool if true, non-maximum suppression is applied to /// detected corners (keypoints).
type AGASTType one of the four neighborhoods as defined in the paper
return KeyPoint[]

Abs() public static method

Computes absolute value of each matrix element
public static Abs ( OpenCvSharp.Mat src ) : MatExpr
src OpenCvSharp.Mat matrix
return MatExpr

Abs() public static method

Computes absolute value of each matrix element
public static Abs ( MatExpr src ) : MatExpr
src MatExpr matrix expression
return MatExpr

Absdiff() public static method

computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
public static Absdiff ( InputArray src1, InputArray src2, OutputArray dst ) : void
src1 InputArray
src2 InputArray
dst OutputArray
return void

Accumulate() public static method

Adds an image to the accumulator.
public static Accumulate ( InputArray src, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void
src InputArray Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst OpenCvSharp.InputOutputArray Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
mask InputArray Optional operation mask.
return void

AccumulateProduct() public static method

Adds the per-element product of two input images to the accumulator.
public static AccumulateProduct ( InputArray src1, InputArray src2, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void
src1 InputArray First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
src2 InputArray Second input image of the same type and the same size as src1
dst OpenCvSharp.InputOutputArray Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point.
mask InputArray Optional operation mask.
return void

AccumulateSquare() public static method

Adds the square of a source image to the accumulator.
public static AccumulateSquare ( InputArray src, OpenCvSharp.InputOutputArray dst, InputArray mask ) : void
src InputArray Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst OpenCvSharp.InputOutputArray Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
mask InputArray Optional operation mask.
return void

AccumulateWeighted() public static method

Updates a running average.
public static AccumulateWeighted ( InputArray src, OpenCvSharp.InputOutputArray dst, double alpha, InputArray mask ) : void
src InputArray Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst OpenCvSharp.InputOutputArray Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
alpha double Weight of the input image.
mask InputArray Optional operation mask.
return void

AdaptiveThreshold() public static method

Applies an adaptive threshold to an array.
public static AdaptiveThreshold ( InputArray src, OutputArray dst, double maxValue, AdaptiveThresholdTypes adaptiveMethod, ThresholdTypes thresholdType, int blockSize, double c ) : void
src InputArray Source 8-bit single-channel image.
dst OutputArray Destination image of the same size and the same type as src .
maxValue double Non-zero value assigned to the pixels for which the condition is satisfied. See the details below.
adaptiveMethod AdaptiveThresholdTypes Adaptive thresholding algorithm to use, ADAPTIVE_THRESH_MEAN_C or ADAPTIVE_THRESH_GAUSSIAN_C .
thresholdType ThresholdTypes Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV .
blockSize int Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
c double Constant subtracted from the mean or weighted mean (see the details below). /// Normally, it is positive but may be zero or negative as well.
return void

Add() public static method

Computes the per-element sum of two arrays or an array and a scalar.
public static Add ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null, int dtype = -1 ) : void
src1 InputArray The first source array
src2 InputArray The second source array. It must have the same size and same type as src1
dst OutputArray The destination array; it will have the same size and same type as src1
mask InputArray The optional operation mask, 8-bit single channel array; specifies elements of the destination array to be changed. [By default this is null]
dtype int
return void

AddWeighted() public static method

computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
public static AddWeighted ( InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype = -1 ) : void
src1 InputArray
alpha double
src2 InputArray
beta double
gamma double
dst OutputArray
dtype int
return void

AlignSize() public static method

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.
public static AlignSize ( int sz, int n ) : int
sz int
n int
return int

ApplyColorMap() public static method

Applies a GNU Octave/MATLAB equivalent colormap on a given image.
public static ApplyColorMap ( InputArray src, OutputArray dst, ColormapTypes colormap ) : void
src InputArray
dst OutputArray
colormap ColormapTypes
return void

ApproxPolyDP() public static method

Approximates contour or a curve using Douglas-Peucker algorithm
public static ApproxPolyDP ( IEnumerable curve, double epsilon, bool closed ) : Point2f[]
curve IEnumerable The polygon or curve to approximate.
epsilon double Specifies the approximation accuracy. /// This is the maximum distance between the original curve and its approximation.
closed bool If true, the approximated curve is closed /// (i.e. its first and last vertices are connected), otherwise it’s not
return Point2f[]

ApproxPolyDP() public static method

Approximates contour or a curve using Douglas-Peucker algorithm
public static ApproxPolyDP ( IEnumerable curve, double epsilon, bool closed ) : System.Point[]
curve IEnumerable The polygon or curve to approximate.
epsilon double Specifies the approximation accuracy. /// This is the maximum distance between the original curve and its approximation.
closed bool The result of the approximation; /// The type should match the type of the input curve
return System.Point[]

ApproxPolyDP() public static method

Approximates contour or a curve using Douglas-Peucker algorithm
public static ApproxPolyDP ( InputArray curve, OutputArray approxCurve, double epsilon, bool closed ) : void
curve InputArray The polygon or curve to approximate. /// Must be 1 x N or N x 1 matrix of type CV_32SC2 or CV_32FC2.
approxCurve OutputArray The result of the approximation; /// The type should match the type of the input curve
epsilon double Specifies the approximation accuracy. /// This is the maximum distance between the original curve and its approximation.
closed bool The result of the approximation; /// The type should match the type of the input curve
return void

ArcLength() public static method

Calculates a contour perimeter or a curve length.
public static ArcLength ( IEnumerable curve, bool closed ) : double
curve IEnumerable The input vector of 2D points.
closed bool Indicates, whether the curve is closed or not.
return double

ArcLength() public static method

Calculates a contour perimeter or a curve length.
public static ArcLength ( IEnumerable curve, bool closed ) : double
curve IEnumerable The input vector of 2D points.
closed bool Indicates, whether the curve is closed or not.
return double

ArcLength() public static method

Calculates a contour perimeter or a curve length.
public static ArcLength ( InputArray curve, bool closed ) : double
curve InputArray The input vector of 2D points, represented by CV_32SC2 or CV_32FC2 matrix.
closed bool Indicates, whether the curve is closed or not.
return double

ArrowedLine() public static method

Draws a arrow segment pointing from the first point to the second one. The function arrowedLine draws an arrow between pt1 and pt2 points in the image. See also cv::line.
public static ArrowedLine ( OpenCvSharp.InputOutputArray img, System.Point pt1, System.Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift, double tipLength = 0.1 ) : void
img OpenCvSharp.InputOutputArray Image.
pt1 System.Point The point the arrow starts from.
pt2 System.Point The point the arrow points to.
color Scalar Line color.
thickness int Line thickness.
lineType LineTypes Type of the line, see cv::LineTypes
shift int Number of fractional bits in the point coordinates.
tipLength double The length of the arrow tip in relation to the arrow length
return void

BatchDistance() public static method

naive nearest neighbor finder
public static BatchDistance ( InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, NormTypes normType = NormTypes.L2, int k, InputArray mask = null, int update, bool crosscheck = false ) : void
src1 InputArray
src2 InputArray
dist OutputArray
dtype int
nidx OutputArray
normType NormTypes
k int
mask InputArray
update int
crosscheck bool
return void

BilateralFilter() public static method

Applies bilateral filter to the image
public static BilateralFilter ( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source 8-bit or floating-point, 1-channel or 3-channel image
dst OutputArray The destination image; will have the same size and the same type as src
d int The diameter of each pixel neighborhood, that is used during filtering. /// If it is non-positive, it's computed from sigmaSpace
sigmaColor double 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
sigmaSpace double 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
borderType BorderTypes
return void

BitwiseAnd() public static method

computes bitwise conjunction of the two arrays (dst = src1 & src2)
public static BitwiseAnd ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void
src1 InputArray
src2 InputArray
dst OutputArray
mask InputArray
return void

BitwiseNot() public static method

inverts each bit of array (dst = ~src)
public static BitwiseNot ( InputArray src, OutputArray dst, InputArray mask = null ) : void
src InputArray
dst OutputArray
mask InputArray
return void

BitwiseOr() public static method

computes bitwise disjunction of the two arrays (dst = src1 | src2)
public static BitwiseOr ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void
src1 InputArray
src2 InputArray
dst OutputArray
mask InputArray
return void

BitwiseXor() public static method

computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
public static BitwiseXor ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void
src1 InputArray
src2 InputArray
dst OutputArray
mask InputArray
return void

Blur() public static method

Smoothes image using normalized box filter
public static Blur ( InputArray src, OutputArray dst, Size ksize, System.Point anchor = null, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same size and the same type as src
ksize Size The smoothing kernel size
anchor System.Point The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center
borderType BorderTypes The border mode used to extrapolate pixels outside of the image
return void

BoundingRect() public static method

Calculates the up-right bounding rectangle of a point set.
public static BoundingRect ( IEnumerable curve ) : Rect
curve IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return Rect

BoundingRect() public static method

Calculates the up-right bounding rectangle of a point set.
public static BoundingRect ( IEnumerable curve ) : Rect
curve IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return Rect

BoundingRect() public static method

Calculates the up-right bounding rectangle of a point set.
public static BoundingRect ( InputArray curve ) : Rect
curve InputArray The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return Rect

BoxFilter() public static method

Smoothes image using box filter
public static BoxFilter ( InputArray src, OutputArray dst, MatType ddepth, Size ksize, System.Point anchor = null, bool normalize = true, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same size and the same type as src
ddepth MatType
ksize Size The smoothing kernel size
anchor System.Point The anchor point. The default value Point(-1,-1) means that the anchor is at the kernel center
normalize bool Indicates, whether the kernel is normalized by its area or not
borderType BorderTypes The border mode used to extrapolate pixels outside of the image
return void

BuildOpticalFlowPyramid() public static method

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK
public static BuildOpticalFlowPyramid ( InputArray img, OpenCvSharp.Mat &pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderTypes pyrBorder = BorderTypes.Reflect101, BorderTypes derivBorder = BorderTypes.Constant, bool tryReuseInputImage = true ) : int
img InputArray 8-bit input image.
pyramid OpenCvSharp.Mat output pyramid.
winSize Size 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.
maxLevel int 0-based maximal pyramid level number.
withDerivatives bool set to precompute gradients for the every pyramid level. /// If pyramid is constructed without the gradients then calcOpticalFlowPyrLK() will /// calculate them internally.
pyrBorder BorderTypes the border mode for pyramid layers.
derivBorder BorderTypes the border mode for gradients.
tryReuseInputImage bool put ROI of input image into the pyramid if possible. /// You can pass false to force data copying.
return int

BuildOpticalFlowPyramid() public static method

Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK
public static BuildOpticalFlowPyramid ( InputArray img, OutputArray pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderTypes pyrBorder = BorderTypes.Reflect101, BorderTypes derivBorder = BorderTypes.Constant, bool tryReuseInputImage = true ) : int
img InputArray 8-bit input image.
pyramid OutputArray output pyramid.
winSize Size 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.
maxLevel int 0-based maximal pyramid level number.
withDerivatives bool set to precompute gradients for the every pyramid level. /// If pyramid is constructed without the gradients then calcOpticalFlowPyrLK() will /// calculate them internally.
pyrBorder BorderTypes the border mode for pyramid layers.
derivBorder BorderTypes the border mode for gradients.
tryReuseInputImage bool put ROI of input image into the pyramid if possible. /// You can pass false to force data copying.
return int

CalcBackProject() public static method

computes the joint dense histogram for a set of images.
public static CalcBackProject ( OpenCvSharp.Mat images, int channels, InputArray hist, OutputArray backProject, OpenCvSharp.Rangef ranges, bool uniform = true ) : void
images OpenCvSharp.Mat
channels int
hist InputArray
backProject OutputArray
ranges OpenCvSharp.Rangef
uniform bool
return void

CalcCovarMatrix() public static method

computes covariation matrix of a set of samples
public static CalcCovarMatrix ( InputArray samples, OutputArray covar, OpenCvSharp.InputOutputArray mean, CovarFlags flags ) : void
samples InputArray
covar OutputArray
mean OpenCvSharp.InputOutputArray
flags CovarFlags
return void

CalcCovarMatrix() public static method

computes covariation matrix of a set of samples
public static CalcCovarMatrix ( InputArray samples, OutputArray covar, OpenCvSharp.InputOutputArray mean, CovarFlags flags, MatType ctype ) : void
samples InputArray
covar OutputArray
mean OpenCvSharp.InputOutputArray
flags CovarFlags
ctype MatType
return void

CalcCovarMatrix() public static method

computes covariation matrix of a set of samples
public static CalcCovarMatrix ( OpenCvSharp.Mat samples, OpenCvSharp.Mat covar, OpenCvSharp.Mat mean, CovarFlags flags ) : void
samples OpenCvSharp.Mat
covar OpenCvSharp.Mat
mean OpenCvSharp.Mat
flags CovarFlags
return void

CalcCovarMatrix() public static method

computes covariation matrix of a set of samples
public static CalcCovarMatrix ( OpenCvSharp.Mat samples, OpenCvSharp.Mat covar, OpenCvSharp.Mat mean, CovarFlags flags, MatType ctype ) : void
samples OpenCvSharp.Mat
covar OpenCvSharp.Mat
mean OpenCvSharp.Mat
flags CovarFlags
ctype MatType
return void

CalcGlobalOrientation() public static method

Computes the global orientation of the selected motion history image part
public static CalcGlobalOrientation ( InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration ) : double
orientation InputArray Motion gradient orientation image calculated by the function CalcMotionGradient() .
mask InputArray 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.
mhi InputArray Motion history image calculated by UpdateMotionHistory() .
timestamp double Timestamp passed to UpdateMotionHistory() .
duration double Maximum duration of a motion track in milliseconds, passed to UpdateMotionHistory() .
return double

CalcHist() public static method

computes the joint dense histogram for a set of images.
public static CalcHist ( OpenCvSharp.Mat images, int channels, InputArray mask, OutputArray hist, int dims, int histSize, OpenCvSharp.Rangef ranges, bool uniform = true, bool accumulate = false ) : void
images OpenCvSharp.Mat
channels int
mask InputArray
hist OutputArray
dims int
histSize int
ranges OpenCvSharp.Rangef
uniform bool
accumulate bool
return void

CalcHist() public static method

computes the joint dense histogram for a set of images.
public static CalcHist ( OpenCvSharp.Mat images, int channels, InputArray mask, OutputArray hist, int dims, int histSize, float ranges, bool uniform = true, bool accumulate = false ) : void
images OpenCvSharp.Mat
channels int
mask InputArray
hist OutputArray
dims int
histSize int
ranges float
uniform bool
accumulate bool
return void

CalcMotionGradient() public static method

Computes the motion gradient orientation image from the motion history image
public static CalcMotionGradient ( InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize = 3 ) : void
mhi InputArray Motion history single-channel floating-point image.
mask OutputArray 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.
orientation OutputArray 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.
delta1 double Minimal (or maximal) allowed difference between mhi values within a pixel neighborhood.
delta2 double 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).
apertureSize int
return void

CalcOpticalFlowFarneback() public static method

Computes a dense optical flow using the Gunnar Farneback's algorithm.
public static CalcOpticalFlowFarneback ( InputArray prev, InputArray next, OpenCvSharp.InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, OpticalFlowFlags flags ) : void
prev InputArray first 8-bit single-channel input image.
next InputArray second input image of the same size and the same type as prev.
flow OpenCvSharp.InputOutputArray computed flow image that has the same size as prev and type CV_32FC2.
pyrScale double 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.
levels int number of pyramid layers including the initial image; /// levels=1 means that no extra layers are created and only the original images are used.
winsize int 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.
iterations int number of iterations the algorithm does at each pyramid level.
polyN int 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.
polySigma double 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.
flags OpticalFlowFlags operation flags that can be a combination of OPTFLOW_USE_INITIAL_FLOW and/or OPTFLOW_FARNEBACK_GAUSSIAN
return void

CalcOpticalFlowPyrLK() public static method

computes sparse optical flow using multi-scale Lucas-Kanade algorithm
public static CalcOpticalFlowPyrLK ( InputArray prevImg, InputArray nextImg, InputArray prevPts, OpenCvSharp.InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize = null, int maxLevel = 3, OpenCvSharp.TermCriteria criteria = null, OpticalFlowFlags flags = OpticalFlowFlags.None, double minEigThreshold = 1e-4 ) : void
prevImg InputArray
nextImg InputArray
prevPts InputArray
nextPts OpenCvSharp.InputOutputArray
status OutputArray
err OutputArray
winSize Size
maxLevel int
criteria OpenCvSharp.TermCriteria
flags OpticalFlowFlags
minEigThreshold double
return void

CalcOpticalFlowPyrLK() public static method

computes sparse optical flow using multi-scale Lucas-Kanade algorithm
public static CalcOpticalFlowPyrLK ( InputArray prevImg, InputArray nextImg, Point2f prevPts, Point2f &nextPts, byte &status, float &err, Size winSize = null, int maxLevel = 3, OpenCvSharp.TermCriteria criteria = null, OpticalFlowFlags flags = OpticalFlowFlags.None, double minEigThreshold = 1e-4 ) : void
prevImg InputArray
nextImg InputArray
prevPts Point2f
nextPts Point2f
status byte
err float
winSize Size
maxLevel int
criteria OpenCvSharp.TermCriteria
flags OpticalFlowFlags
minEigThreshold double
return void

CalcOpticalFlowSF() public static method

computes dense optical flow using Simple Flow algorithm
public static CalcOpticalFlowSF ( OpenCvSharp.Mat from, OpenCvSharp.Mat to, OpenCvSharp.Mat flow, int layers, int averagingBlockSize, int maxFlow ) : void
from OpenCvSharp.Mat First 8-bit 3-channel image.
to OpenCvSharp.Mat Second 8-bit 3-channel image
flow OpenCvSharp.Mat Estimated flow
layers int Number of layers
averagingBlockSize int Size of block through which we sum up when calculate cost function for pixel
maxFlow int maximal flow that we search at each level
return void

CalibrateCamera() public static method

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
public static CalibrateCamera ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, OpenCvSharp.InputOutputArray cameraMatrix, OpenCvSharp.InputOutputArray distCoeffs, OpenCvSharp.Mat &rvecs, OpenCvSharp.Mat &tvecs, CalibrationFlags flags = CalibrationFlags.None, OpenCvSharp.TermCriteria criteria = null ) : double
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
imageSize Size Size of the image used only to initialize the intrinsic camera matrix.
cameraMatrix OpenCvSharp.InputOutputArray 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.
distCoeffs OpenCvSharp.InputOutputArray 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.
rvecs OpenCvSharp.Mat 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)
tvecs OpenCvSharp.Mat Output vector of translation vectors estimated for each pattern view.
flags CalibrationFlags Different flags that may be zero or a combination of the CalibrationFlag values
criteria OpenCvSharp.TermCriteria Termination criteria for the iterative optimization algorithm.
return double

CalibrateCamera() public static method

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
public static CalibrateCamera ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double cameraMatrix, double distCoeffs, Vec3d &rvecs, Vec3d &tvecs, CalibrationFlags flags = CalibrationFlags.None, OpenCvSharp.TermCriteria criteria = null ) : double
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
imageSize Size Size of the image used only to initialize the intrinsic camera matrix.
cameraMatrix double 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.
distCoeffs double 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.
rvecs Vec3d 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)
tvecs Vec3d Output vector of translation vectors estimated for each pattern view.
flags CalibrationFlags Different flags that may be zero or a combination of the CalibrationFlag values
criteria OpenCvSharp.TermCriteria Termination criteria for the iterative optimization algorithm.
return double

CalibrationMatrixValues() public static method

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
public static CalibrationMatrixValues ( InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio ) : void
cameraMatrix InputArray Input camera matrix that can be estimated by calibrateCamera() or stereoCalibrate() .
imageSize Size Input image size in pixels.
apertureWidth double Physical width of the sensor.
apertureHeight double Physical height of the sensor.
fovx double Output field of view in degrees along the horizontal sensor axis.
fovy double Output field of view in degrees along the vertical sensor axis.
focalLength double Focal length of the lens in mm.
principalPoint Point2d Principal point in pixels.
aspectRatio double fy / fx
return void

CalibrationMatrixValues() public static method

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
public static CalibrationMatrixValues ( double cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio ) : void
cameraMatrix double Input camera matrix that can be estimated by calibrateCamera() or stereoCalibrate() .
imageSize Size Input image size in pixels.
apertureWidth double Physical width of the sensor.
apertureHeight double Physical height of the sensor.
fovx double Output field of view in degrees along the horizontal sensor axis.
fovy double Output field of view in degrees along the vertical sensor axis.
focalLength double Focal length of the lens in mm.
principalPoint Point2d Principal point in pixels.
aspectRatio double fy / fx
return void

CamShift() public static method

Finds an object center, size, and orientation.
public static CamShift ( InputArray probImage, Rect &window, OpenCvSharp.TermCriteria criteria ) : OpenCvSharp.RotatedRect
probImage InputArray Back projection of the object histogram.
window Rect Initial search window.
criteria OpenCvSharp.TermCriteria Stop criteria for the underlying MeanShift() .
return OpenCvSharp.RotatedRect

Canny() public static method

Finds edges in an image using Canny algorithm.
public static Canny ( InputArray src, OutputArray edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false ) : void
src InputArray Single-channel 8-bit input image
edges OutputArray The output edge map. It will have the same size and the same type as image
threshold1 double The first threshold for the hysteresis procedure
threshold2 double The second threshold for the hysteresis procedure
apertureSize int Aperture size for the Sobel operator [By default this is ApertureSize.Size3]
L2gradient bool 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]
return void

CartToPolar() public static method

converts Cartesian coordinates to polar
public static CartToPolar ( InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees = false ) : void
x InputArray
y InputArray
magnitude OutputArray
angle OutputArray
angleInDegrees bool
return void

CheckHardwareSupport() public static method

public static CheckHardwareSupport ( CpuFeatures feature ) : bool
feature CpuFeatures
return bool

CheckRange() public static method

checks that each matrix element is within the specified range.
public static CheckRange ( InputArray src, bool quiet = true ) : bool
src InputArray The array to check
quiet bool The flag indicating whether the functions quietly /// return false when the array elements are out of range, /// or they throw an exception.
return bool

CheckRange() public static method

checks that each matrix element is within the specified range.
public static CheckRange ( InputArray src, bool quiet, System.Point &pos, double minVal = double.MinValue, double maxVal = double.MaxValue ) : bool
src InputArray The array to check
quiet bool The flag indicating whether the functions quietly /// return false when the array elements are out of range, /// or they throw an exception.
pos System.Point The optional output parameter, where the position of /// the first outlier is stored.
minVal double The inclusive lower boundary of valid values range
maxVal double The exclusive upper boundary of valid values range
return bool

Circle() public static method

Draws a circle
public static Circle ( OpenCvSharp.InputOutputArray img, System.Point center, int radius, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img OpenCvSharp.InputOutputArray Image where the circle is drawn.
center System.Point Center of the circle.
radius int Radius of the circle.
color Scalar Circle color.
thickness int Thickness of the circle outline if positive, otherwise indicates that a filled circle has to be drawn. [By default this is 1]
lineType LineTypes Type of the circle boundary. [By default this is LineType.Link8]
shift int Number of fractional bits in the center coordinates and radius value. [By default this is 0]
return void

Circle() public static method

Draws a circle
public static Circle ( OpenCvSharp.InputOutputArray img, int centerX, int centerY, int radius, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img OpenCvSharp.InputOutputArray Image where the circle is drawn.
centerX int X-coordinate of the center of the circle.
centerY int Y-coordinate of the center of the circle.
radius int Radius of the circle.
color Scalar Circle color.
thickness int Thickness of the circle outline if positive, otherwise indicates that a filled circle has to be drawn. [By default this is 1]
lineType LineTypes Type of the circle boundary. [By default this is LineType.Link8]
shift int Number of fractional bits in the center coordinates and radius value. [By default this is 0]
return void

ClipLine() public static method

Clips the line against the image rectangle
public static ClipLine ( Rect imgRect, System.Point &pt1, System.Point &pt2 ) : bool
imgRect Rect sThe image rectangle
pt1 System.Point The first line point
pt2 System.Point The second line point
return bool

ClipLine() public static method

Clips the line against the image rectangle
public static ClipLine ( Size imgSize, System.Point &pt1, System.Point &pt2 ) : bool
imgSize Size The image size
pt1 System.Point The first line point
pt2 System.Point The second line point
return bool

ColorChange() public static method

Given an original color image, two differently colored versions of this image can be mixed seamlessly. Multiplication factor is between 0.5 to 2.5.
public static ColorChange ( InputArray src, InputArray mask, OutputArray dst, float redMul = 1.0f, float greenMul = 1.0f, float blueMul = 1.0f ) : void
src InputArray Input 8-bit 3-channel image.
mask InputArray Input 8-bit 1 or 3-channel image.
dst OutputArray Output image with the same size and type as src.
redMul float R-channel multiply factor.
greenMul float G-channel multiply factor.
blueMul float B-channel multiply factor.
return void

Compare() public static method

Performs the per-element comparison of two arrays or an array and scalar value.
public static Compare ( InputArray src1, InputArray src2, OutputArray dst, CmpTypes cmpop ) : void
src1 InputArray first input array or a scalar; when it is an array, it must have a single channel.
src2 InputArray second input array or a scalar; when it is an array, it must have a single channel.
dst OutputArray output array of type ref CV_8U that has the same size and the same number of channels as the input arrays.
cmpop CmpTypes a flag, that specifies correspondence between the arrays (cv::CmpTypes)
return void

CompareHist() public static method

compares two histograms stored in dense arrays
public static CompareHist ( InputArray h1, InputArray h2, HistCompMethods method ) : double
h1 InputArray The first compared histogram
h2 InputArray The second compared histogram of the same size as h1
method HistCompMethods The comparison method
return double

CompleteSymm() public static method

extends the symmetrical matrix from the lower half or from the upper half
public static CompleteSymm ( OpenCvSharp.InputOutputArray mtx, bool lowerToUpper = false ) : void
mtx OpenCvSharp.InputOutputArray Input-output floating-point square matrix
lowerToUpper bool If true, the lower half is copied to the upper half, /// otherwise the upper half is copied to the lower half
return void

ComposeRT() public static method

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
public static ComposeRT ( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1 = null, OutputArray dr3dt1 = null, OutputArray dr3dr2 = null, OutputArray dr3dt2 = null, OutputArray dt3dr1 = null, OutputArray dt3dt1 = null, OutputArray dt3dr2 = null, OutputArray dt3dt2 = null ) : void
rvec1 InputArray First rotation vector.
tvec1 InputArray First translation vector.
rvec2 InputArray Second rotation vector.
tvec2 InputArray Second translation vector.
rvec3 OutputArray Output rotation vector of the superposition.
tvec3 OutputArray Output translation vector of the superposition.
dr3dr1 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dt1 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dr2 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dt2 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dr1 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dt1 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dr2 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dt2 OutputArray Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
return void

ComposeRT() public static method

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
public static ComposeRT ( double rvec1, double tvec1, double rvec2, double tvec2, double &rvec3, double &tvec3 ) : void
rvec1 double First rotation vector.
tvec1 double First translation vector.
rvec2 double Second rotation vector.
tvec2 double Second translation vector.
rvec3 double Output rotation vector of the superposition.
tvec3 double Output translation vector of the superposition.
return void

ComposeRT() public static method

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
public static ComposeRT ( double rvec1, double tvec1, double rvec2, double tvec2, double &rvec3, double &tvec3, double &dr3dr1, double &dr3dt1, double &dr3dr2, double &dr3dt2, double &dt3dr1, double &dt3dt1, double &dt3dr2, double &dt3dt2 ) : void
rvec1 double First rotation vector.
tvec1 double First translation vector.
rvec2 double Second rotation vector.
tvec2 double Second translation vector.
rvec3 double Output rotation vector of the superposition.
tvec3 double Output translation vector of the superposition.
dr3dr1 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dt1 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dr2 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dr3dt2 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dr1 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dt1 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dr2 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
dt3dt2 double Optional output derivatives of rvec3 or tvec3 with regard to rvec1, rvec2, tvec1 and tvec2, respectively.
return void

ComputeCorrespondEpilines() public static method

For points in an image of a stereo pair, computes the corresponding epilines in the other image.
public static ComputeCorrespondEpilines ( IEnumerable points, int whichImage, double F ) : Point3f[]
points IEnumerable Input points. N \times 1 or 1 x N matrix of type CV_32FC2 or CV_64FC2.
whichImage int Index of the image (1 or 2) that contains the points .
F double Fundamental matrix that can be estimated using findFundamentalMat() or stereoRectify() .
return Point3f[]

ComputeCorrespondEpilines() public static method

For points in an image of a stereo pair, computes the corresponding epilines in the other image.
public static ComputeCorrespondEpilines ( IEnumerable points, int whichImage, double F ) : Point3f[]
points IEnumerable Input points. N \times 1 or 1 x N matrix of type CV_32FC2 or CV_64FC2.
whichImage int Index of the image (1 or 2) that contains the points .
F double Fundamental matrix that can be estimated using findFundamentalMat() or stereoRectify() .
return Point3f[]

ComputeCorrespondEpilines() public static method

For points in an image of a stereo pair, computes the corresponding epilines in the other image.
public static ComputeCorrespondEpilines ( InputArray points, int whichImage, InputArray F, OutputArray lines ) : void
points InputArray Input points. N \times 1 or 1 x N matrix of type CV_32FC2 or CV_64FC2.
whichImage int Index of the image (1 or 2) that contains the points .
F InputArray Fundamental matrix that can be estimated using findFundamentalMat() or stereoRectify() .
lines OutputArray 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) .
return void

ComputeRecallPrecisionCurve() public static method

public static ComputeRecallPrecisionCurve ( OpenCvSharp.DMatch matches1to2, byte correctMatches1to2Mask ) : Point2f[]
matches1to2 OpenCvSharp.DMatch
correctMatches1to2Mask byte
return Point2f[]

ConnectedComponents() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponents ( InputArray image, OutputArray labels, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : int
image InputArray the image to be labeled
labels OutputArray destination labeled image
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
return int

ConnectedComponents() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponents ( InputArray image, OutputArray labels, PixelConnectivity connectivity, MatType ltype ) : int
image InputArray the image to be labeled
labels OutputArray destination labeled image
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
ltype MatType output image label type. Currently CV_32S and CV_16U are supported.
return int

ConnectedComponents() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponents ( InputArray image, int &labels, PixelConnectivity connectivity ) : int
image InputArray the image to be labeled
labels int destination labeled rectangular array
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
return int

ConnectedComponentsEx() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponentsEx ( InputArray image, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : ConnectedComponents
image InputArray the image to be labeled
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
return ConnectedComponents

ConnectedComponentsWithStats() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponentsWithStats ( InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : int
image InputArray the image to be labeled
labels OutputArray destination labeled image
stats OutputArray statistics output for each label, including the background label, /// see below for available statistics. Statistics are accessed via stats(label, COLUMN) /// where COLUMN is one of cv::ConnectedComponentsTypes
centroids OutputArray floating point centroid (x,y) output for each label, /// including the background label
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
return int

ConnectedComponentsWithStats() public static method

computes the connected components labeled image of boolean image. image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
public static ConnectedComponentsWithStats ( InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, PixelConnectivity connectivity, MatType ltype ) : int
image InputArray the image to be labeled
labels OutputArray destination labeled image
stats OutputArray statistics output for each label, including the background label, /// see below for available statistics. Statistics are accessed via stats(label, COLUMN) /// where COLUMN is one of cv::ConnectedComponentsTypes
centroids OutputArray floating point centroid (x,y) output for each label, /// including the background label
connectivity PixelConnectivity 8 or 4 for 8-way or 4-way connectivity respectively
ltype MatType output image label type. Currently CV_32S and CV_16U are supported.
return int

ContourArea() public static method

Calculates the contour area
public static ContourArea ( IEnumerable contour, bool oriented = false ) : double
contour IEnumerable The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix
oriented bool
return double

ContourArea() public static method

Calculates the contour area
public static ContourArea ( IEnumerable contour, bool oriented = false ) : double
contour IEnumerable The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix
oriented bool
return double

ContourArea() public static method

Calculates the contour area
public static ContourArea ( InputArray contour, bool oriented = false ) : double
contour InputArray The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix
oriented bool
return double

ConvertImage() public static method

utility function: convert one image to another with optional vertical flip
public static ConvertImage ( OpenCvSharp.Mat src, OpenCvSharp.Mat dst, ConvertImageModes flags = ConvertImageModes.None ) : void
src OpenCvSharp.Mat
dst OpenCvSharp.Mat
flags ConvertImageModes
return void

ConvertMaps() public static method

public static ConvertMaps ( InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, MatType dstmap1Type, bool nnInterpolation = false ) : void
map1 InputArray
map2 InputArray
dstmap1 OutputArray
dstmap2 OutputArray
dstmap1Type MatType
nnInterpolation bool
return void

ConvertPointsFromHomogeneous() public static method

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
public static ConvertPointsFromHomogeneous ( IEnumerable src ) : Vec2f[]
src IEnumerable Input vector of N-dimensional points.
return Vec2f[]

ConvertPointsFromHomogeneous() public static method

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
public static ConvertPointsFromHomogeneous ( IEnumerable src ) : Vec3f[]
src IEnumerable Input vector of N-dimensional points.
return Vec3f[]

ConvertPointsFromHomogeneous() public static method

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
public static ConvertPointsFromHomogeneous ( InputArray src, OutputArray dst ) : void
src InputArray Input vector of N-dimensional points.
dst OutputArray Output vector of N-1-dimensional points.
return void

ConvertPointsHomogeneous() public static method

Converts points to/from homogeneous coordinates.
public static ConvertPointsHomogeneous ( InputArray src, OutputArray dst ) : void
src InputArray Input array or vector of 2D, 3D, or 4D points.
dst OutputArray Output vector of 2D, 3D, or 4D points.
return void

ConvertPointsToHomogeneous() public static method

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
public static ConvertPointsToHomogeneous ( IEnumerable src ) : Vec3f[]
src IEnumerable Input vector of N-dimensional points.
return Vec3f[]

ConvertPointsToHomogeneous() public static method

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
public static ConvertPointsToHomogeneous ( IEnumerable src ) : Vec4f[]
src IEnumerable Input vector of N-dimensional points.
return Vec4f[]

ConvertPointsToHomogeneous() public static method

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
public static ConvertPointsToHomogeneous ( InputArray src, OutputArray dst ) : void
src InputArray Input vector of N-dimensional points.
dst OutputArray Output vector of N+1-dimensional points.
return void

ConvertScaleAbs() public static method

Scales, computes absolute values and converts the result to 8-bit.
public static ConvertScaleAbs ( InputArray src, OutputArray dst, double alpha = 1, double beta ) : void
src InputArray The source array
dst OutputArray The destination array
alpha double The optional scale factor. [By default this is 1]
beta double The optional delta added to the scaled values. [By default this is 0]
return void

ConvexHull() public static method

Computes convex hull for a set of 2D points.
public static ConvexHull ( IEnumerable points, bool clockwise = false ) : Point2f[]
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix
clockwise bool 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.
return Point2f[]

ConvexHull() public static method

Computes convex hull for a set of 2D points.
public static ConvexHull ( IEnumerable points, bool clockwise = false ) : System.Point[]
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix
clockwise bool 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.
return System.Point[]

ConvexHull() public static method

Computes convex hull for a set of 2D points.
public static ConvexHull ( InputArray points, OutputArray hull, bool clockwise = false, bool returnPoints = true ) : void
points InputArray The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix
hull OutputArray 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).
clockwise bool 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.
returnPoints bool
return void

ConvexHullIndices() public static method

Computes convex hull for a set of 2D points.
public static ConvexHullIndices ( IEnumerable points, bool clockwise = false ) : int[]
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix
clockwise bool 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.
return int[]

ConvexHullIndices() public static method

Computes convex hull for a set of 2D points.
public static ConvexHullIndices ( IEnumerable points, bool clockwise = false ) : int[]
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix
clockwise bool 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.
return int[]

ConvexityDefects() public static method

Computes the contour convexity defects
public static ConvexityDefects ( IEnumerable contour, IEnumerable convexHull ) : Vec4i[]
contour IEnumerable Input contour.
convexHull IEnumerable Convex hull obtained using convexHull() that /// should contain indices of the contour points that make the hull.
return Vec4i[]

ConvexityDefects() public static method

Computes the contour convexity defects
public static ConvexityDefects ( IEnumerable contour, IEnumerable convexHull ) : Vec4i[]
contour IEnumerable Input contour.
convexHull IEnumerable Convex hull obtained using convexHull() that /// should contain indices of the contour points that make the hull.
return Vec4i[]

ConvexityDefects() public static method

Computes the contour convexity defects
public static ConvexityDefects ( InputArray contour, InputArray convexHull, OutputArray convexityDefects ) : void
contour InputArray Input contour.
convexHull InputArray Convex hull obtained using convexHull() that /// should contain indices of the contour points that make the hull.
convexityDefects OutputArray /// 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. ///
return void

CopyMakeBorder() public static method

Forms a border around the image
public static CopyMakeBorder ( InputArray src, OutputArray dst, int top, int bottom, int left, int right, BorderTypes borderType, Scalar value = null ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same type as src and /// the size Size(src.cols+left+right, src.rows+top+bottom)
top int Specify how much pixels in each direction from the source image rectangle one needs to extrapolate
bottom int Specify how much pixels in each direction from the source image rectangle one needs to extrapolate
left int Specify how much pixels in each direction from the source image rectangle one needs to extrapolate
right int Specify how much pixels in each direction from the source image rectangle one needs to extrapolate
borderType BorderTypes The border type
value Scalar The border value if borderType == Constant
return void

CornerEigenValsAndVecs() public static method

computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.
public static CornerEigenValsAndVecs ( InputArray src, OutputArray dst, int blockSize, int ksize, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray
dst OutputArray
blockSize int
ksize int
borderType BorderTypes
return void

CornerSubPix() public static method

adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
public static CornerSubPix ( InputArray image, IEnumerable inputCorners, Size winSize, Size zeroZone, OpenCvSharp.TermCriteria criteria ) : Point2f[]
image InputArray Input image.
inputCorners IEnumerable Initial coordinates of the input corners and refined coordinates provided for output.
winSize Size Half of the side length of the search window.
zeroZone Size 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 OpenCvSharp.TermCriteria 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.
return Point2f[]

CorrectMatches() public static method

Refines coordinates of corresponding points.
public static CorrectMatches ( InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2 ) : void
F InputArray 3x3 fundamental matrix.
points1 InputArray 1xN array containing the first set of points.
points2 InputArray 1xN array containing the second set of points.
newPoints1 OutputArray The optimized points1.
newPoints2 OutputArray The optimized points2.
return void

CorrectMatches() public static method

Refines coordinates of corresponding points.
public static CorrectMatches ( double F, IEnumerable points1, IEnumerable points2, Point2d &newPoints1, Point2d &newPoints2 ) : void
F double 3x3 fundamental matrix.
points1 IEnumerable 1xN array containing the first set of points.
points2 IEnumerable 1xN array containing the second set of points.
newPoints1 Point2d The optimized points1.
newPoints2 Point2d The optimized points2.
return void

CountNonZero() public static method

computes the number of nonzero array elements
public static CountNonZero ( InputArray mtx ) : int
mtx InputArray Single-channel array
return int

CreateCLAHE() public static method

Creates a predefined CLAHE object
public static CreateCLAHE ( double clipLimit = 40.0, Size tileGridSize = null ) : CLAHE
clipLimit double
tileGridSize Size
return CLAHE

CreateHanningWindow() public static method

Computes a Hanning window coefficients in two dimensions.
public static CreateHanningWindow ( OpenCvSharp.InputOutputArray dst, Size winSize, MatType type ) : void
dst OpenCvSharp.InputOutputArray Destination array to place Hann coefficients in
winSize Size The window size specifications
type MatType Created array type
return void

CreateOptFlow_DualTVL1() public static method

Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
public static CreateOptFlow_DualTVL1 ( ) : OpenCvSharp.DenseOpticalFlow
return OpenCvSharp.DenseOpticalFlow

CubeRoot() public static method

computes cube root of the argument
public static CubeRoot ( float val ) : float
val float
return float

CvtColor() public static method

Converts image from one color space to another
public static CvtColor ( InputArray src, OutputArray dst, ColorConversionCodes code, int dstCn ) : void
src InputArray The source image, 8-bit unsigned, 16-bit unsigned or single-precision floating-point
dst OutputArray The destination image; will have the same size and the same depth as src
code ColorConversionCodes The color space conversion code
dstCn int 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
return void

Dct() public static method

Performs forward or inverse 1D or 2D Discrete Cosine Transformation
public static Dct ( InputArray src, OutputArray dst, DctFlags flags = DctFlags.None ) : void
src InputArray The source floating-point array
dst OutputArray The destination array; will have the same size and same type as src
flags DctFlags Transformation flags, a combination of DctFlag2 values
return void

Decolor() public static method

Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications @cite CL12 .
public static Decolor ( InputArray src, OutputArray grayscale, OutputArray colorBoost ) : void
src InputArray Input 8-bit 3-channel image.
grayscale OutputArray Output 8-bit 1-channel image.
colorBoost OutputArray Output 8-bit 3-channel image.
return void

DecomposeProjectionMatrix() public static method

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
public static DecomposeProjectionMatrix ( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX = null, OutputArray rotMatrixY = null, OutputArray rotMatrixZ = null, OutputArray eulerAngles = null ) : void
projMatrix InputArray 3x4 input projection matrix P.
cameraMatrix OutputArray Output 3x3 camera matrix K.
rotMatrix OutputArray Output 3x3 external rotation matrix R.
transVect OutputArray Output 4x1 translation vector T.
rotMatrixX OutputArray Optional 3x3 rotation matrix around x-axis.
rotMatrixY OutputArray Optional 3x3 rotation matrix around y-axis.
rotMatrixZ OutputArray Optional 3x3 rotation matrix around z-axis.
eulerAngles OutputArray ptional three-element vector containing three Euler angles of rotation in degrees.
return void

DecomposeProjectionMatrix() public static method

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
public static DecomposeProjectionMatrix ( double projMatrix, double &cameraMatrix, double &rotMatrix, double &transVect ) : void
projMatrix double 3x4 input projection matrix P.
cameraMatrix double Output 3x3 camera matrix K.
rotMatrix double Output 3x3 external rotation matrix R.
transVect double Output 4x1 translation vector T.
return void

DecomposeProjectionMatrix() public static method

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
public static DecomposeProjectionMatrix ( double projMatrix, double &cameraMatrix, double &rotMatrix, double &transVect, double &rotMatrixX, double &rotMatrixY, double &rotMatrixZ, double &eulerAngles ) : void
projMatrix double 3x4 input projection matrix P.
cameraMatrix double Output 3x3 camera matrix K.
rotMatrix double Output 3x3 external rotation matrix R.
transVect double Output 4x1 translation vector T.
rotMatrixX double Optional 3x3 rotation matrix around x-axis.
rotMatrixY double Optional 3x3 rotation matrix around y-axis.
rotMatrixZ double Optional 3x3 rotation matrix around z-axis.
eulerAngles double ptional three-element vector containing three Euler angles of rotation in degrees.
return void

DenoiseTVL1() public static method

Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.
public static DenoiseTVL1 ( IEnumerable observations, OpenCvSharp.Mat result, double lambda = 1.0, int niters = 30 ) : void
observations IEnumerable This array should contain one or more noised versions /// of the image that is to be restored.
result OpenCvSharp.Mat Here the denoised image will be stored. There is no need to /// do pre-allocation of storage space, as it will be automatically allocated, if necessary.
lambda double Corresponds to \f$\lambda\f$ in the formulas above. /// As it is enlarged, the smooth (blurred) images are treated more favorably than /// detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, /// the result will be more blur but more sever outliers will be removed.
niters int Number of iterations that the algorithm will run. /// Of course, as more iterations as better, but it is hard to quantitatively /// refine this statement, so just use the default and increase it if the results are poor.
return void

DestroyAllWindows() public static method

public static DestroyAllWindows ( ) : void
return void

DestroyWindow() public static method

public static DestroyWindow ( string winName ) : void
winName string
return void

DetailEnhance() public static method

This filter enhances the details of a particular image.
public static DetailEnhance ( InputArray src, OutputArray dst, float sigmaS = 10, float sigmaR = 0.15f ) : void
src InputArray Input 8-bit 3-channel image.
dst OutputArray Output image with the same size and type as src.
sigmaS float Range between 0 to 200.
sigmaR float Range between 0 to 1.
return void

Determinant() public static method

computes determinant of a square matrix
public static Determinant ( InputArray mtx ) : double
mtx InputArray The input matrix; must have CV_32FC1 or CV_64FC1 type and square size
return double

Dft() public static method

Performs a forward Discrete Fourier transform of 1D or 2D floating-point array.
public static Dft ( InputArray src, OutputArray dst, DftFlags flags = DftFlags.None, int nonzeroRows ) : void
src InputArray The source array, real or complex
dst OutputArray The destination array, which size and type depends on the flags
flags DftFlags Transformation flags, a combination of the DftFlag2 values
nonzeroRows int 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
return void

Dilate() public static method

Dilates an image by using a specific structuring element.
public static Dilate ( InputArray src, OutputArray dst, InputArray element, System.Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray The source image
dst OutputArray The destination image. It will have the same size and the same type as src
element InputArray The structuring element used for dilation. If element=new Mat() , a 3x3 rectangular structuring element is used
anchor System.Point Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center
iterations int The number of times dilation is applied. [By default this is 1]
borderType BorderTypes The pixel extrapolation method. [By default this is BorderType.Constant]
borderValue Scalar The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]
return void

DistanceTransform() public static method

computes the distance transform map
public static DistanceTransform ( InputArray src, OutputArray dst, DistanceTypes distanceType, DistanceMaskSize maskSize ) : void
src InputArray
dst OutputArray
distanceType DistanceTypes
maskSize DistanceMaskSize
return void

DistanceTransformWithLabels() public static method

builds the discrete Voronoi diagram
public static DistanceTransformWithLabels ( InputArray src, OutputArray dst, OutputArray labels, DistanceTypes distanceType, DistanceMaskSize maskSize, DistanceTransformLabelTypes labelType = DistanceTransformLabelTypes.CComp ) : void
src InputArray
dst OutputArray
labels OutputArray
distanceType DistanceTypes
maskSize DistanceMaskSize
labelType DistanceTransformLabelTypes
return void

Divide() public static method

Performs per-element division of two arrays or a scalar by an array.
public static Divide ( InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1 ) : void
src1 InputArray The first source array
src2 InputArray The second source array; should have the same size and same type as src1
dst OutputArray The destination array; will have the same size and same type as src2
scale double Scale factor [By default this is 1]
dtype int
return void

Divide() public static method

Performs per-element division of two arrays or a scalar by an array.
public static Divide ( double scale, InputArray src2, OutputArray dst, int dtype = -1 ) : void
scale double Scale factor
src2 InputArray The first source array
dst OutputArray The destination array; will have the same size and same type as src2
dtype int
return void

DrawChessboardCorners() public static method

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

DrawChessboardCorners() public static method

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

DrawContours() public static method

draws contours in the image
public static DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable contours, int contourIdx, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, OpenCvSharp.Mat hierarchy = null, int maxLevel = Int32.MaxValue, System.Point offset = null ) : void
image OpenCvSharp.InputOutputArray Destination image.
contours IEnumerable All the input contours. Each contour is stored as a point vector.
contourIdx int Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
color Scalar Color of the contours.
thickness int Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), /// the contour interiors are drawn.
lineType LineTypes Line connectivity.
hierarchy OpenCvSharp.Mat Optional information about hierarchy. It is only needed if you want to draw only some of the contours
maxLevel int 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.
offset System.Point Optional contour shift parameter. Shift all the drawn contours by the specified offset = (dx, dy)
return void

DrawContours() public static method

draws contours in the image
public static DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable contours, int contourIdx, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, IEnumerable hierarchy = null, int maxLevel = Int32.MaxValue, System.Point offset = null ) : void
image OpenCvSharp.InputOutputArray Destination image.
contours IEnumerable All the input contours. Each contour is stored as a point vector.
contourIdx int Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
color Scalar Color of the contours.
thickness int Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), /// the contour interiors are drawn.
lineType LineTypes Line connectivity.
hierarchy IEnumerable Optional information about hierarchy. It is only needed if you want to draw only some of the contours
maxLevel int 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.
offset System.Point Optional contour shift parameter. Shift all the drawn contours by the specified offset = (dx, dy)
return void

DrawKeypoints() public static method

Draw keypoints.
public static DrawKeypoints ( OpenCvSharp.Mat image, IEnumerable keypoints, OpenCvSharp.Mat outImage, Scalar color = null, DrawMatchesFlags flags = DrawMatchesFlags.Default ) : void
image OpenCvSharp.Mat
keypoints IEnumerable
outImage OpenCvSharp.Mat
color Scalar
flags DrawMatchesFlags
return void

DrawMatches() public static method

Draws matches of keypints from two images on output image.
public static DrawMatches ( OpenCvSharp.Mat img1, IEnumerable keypoints1, OpenCvSharp.Mat img2, IEnumerable keypoints2, IEnumerable matches1To2, OpenCvSharp.Mat outImg, Scalar matchColor = null, Scalar singlePointColor = null, IEnumerable matchesMask = null, DrawMatchesFlags flags = DrawMatchesFlags.Default ) : void
img1 OpenCvSharp.Mat
keypoints1 IEnumerable
img2 OpenCvSharp.Mat
keypoints2 IEnumerable
matches1To2 IEnumerable
outImg OpenCvSharp.Mat
matchColor Scalar
singlePointColor Scalar
matchesMask IEnumerable
flags DrawMatchesFlags
return void

EMD() public static method

public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType ) : float
signature1 InputArray
signature2 InputArray
distType DistanceTypes
return float

EMD() public static method

public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost ) : float
signature1 InputArray
signature2 InputArray
distType DistanceTypes
cost InputArray
return float

EMD() public static method

public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost, float &lowerBound ) : float
signature1 InputArray
signature2 InputArray
distType DistanceTypes
cost InputArray
lowerBound float
return float

EMD() public static method

public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost, float &lowerBound, OutputArray flow ) : float
signature1 InputArray
signature2 InputArray
distType DistanceTypes
cost InputArray
lowerBound float
flow OutputArray
return float

EdgePreservingFilter() public static method

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications @cite EM11 .
public static EdgePreservingFilter ( InputArray src, OutputArray dst, EdgePreservingMethods flags = EdgePreservingMethods.RecursFilter, float sigmaS = 60, float sigmaR = 0.4f ) : void
src InputArray Input 8-bit 3-channel image.
dst OutputArray Output 8-bit 3-channel image.
flags EdgePreservingMethods Edge preserving filters
sigmaS float Range between 0 to 200.
sigmaR float Range between 0 to 1.
return void

Eigen() public static method

Computes eigenvalues and eigenvectors of a symmetric matrix.
public static Eigen ( InputArray src, OutputArray eigenvalues, OutputArray eigenvectors ) : bool
src InputArray The input matrix; must have CV_32FC1 or CV_64FC1 type, /// square size and be symmetric: src^T == src
eigenvalues OutputArray The output vector of eigenvalues of the same type as src; /// The eigenvalues are stored in the descending order.
eigenvectors OutputArray 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
return bool

Ellipse() public static method

Draws simple or thick elliptic arc or fills ellipse sector
public static Ellipse ( OpenCvSharp.InputOutputArray img, System.Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img OpenCvSharp.InputOutputArray Image.
center System.Point Center of the ellipse.
axes Size Length of the ellipse axes.
angle double Rotation angle.
startAngle double Starting angle of the elliptic arc.
endAngle double Ending angle of the elliptic arc.
color Scalar Ellipse color.
thickness int Thickness of the ellipse arc. [By default this is 1]
lineType LineTypes Type of the ellipse boundary. [By default this is LineType.Link8]
shift int Number of fractional bits in the center coordinates and axes' values. [By default this is 0]
return void

Ellipse() public static method

Draws simple or thick elliptic arc or fills ellipse sector
public static Ellipse ( OpenCvSharp.InputOutputArray img, OpenCvSharp.RotatedRect box, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8 ) : void
img OpenCvSharp.InputOutputArray Image.
box OpenCvSharp.RotatedRect The enclosing box of the ellipse drawn
color Scalar Ellipse color.
thickness int Thickness of the ellipse boundary. [By default this is 1]
lineType LineTypes Type of the ellipse boundary. [By default this is LineType.Link8]
return void

Ellipse2Poly() public static method

Approximates an elliptic arc with a polyline. The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by cv::ellipse.
public static Ellipse2Poly ( System.Point center, Size axes, int angle, int arcStart, int arcEnd, int delta ) : System.Point[]
center System.Point Center of the arc.
axes Size Half of the size of the ellipse main axes. See the ellipse for details.
angle int Rotation angle of the ellipse in degrees. See the ellipse for details.
arcStart int Starting angle of the elliptic arc in degrees.
arcEnd int Ending angle of the elliptic arc in degrees.
delta int Angle between the subsequent polyline vertices. It defines the approximation
return System.Point[]

EqualizeHist() public static method

normalizes the grayscale image brightness and contrast by normalizing its histogram
public static EqualizeHist ( InputArray src, OutputArray dst ) : void
src InputArray The source 8-bit single channel image
dst OutputArray The destination image; will have the same size and the same type as src
return void

Erode() public static method

Erodes an image by using a specific structuring element.
public static Erode ( InputArray src, OutputArray dst, InputArray element, System.Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray The source image
dst OutputArray The destination image. It will have the same size and the same type as src
element InputArray The structuring element used for dilation. If element=new Mat(), a 3x3 rectangular structuring element is used
anchor System.Point Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center
iterations int The number of times erosion is applied
borderType BorderTypes The pixel extrapolation method
borderValue Scalar The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]
return void

EstimateAffine3D() public static method

Computes an optimal affine transformation between two 3D point sets.
public static EstimateAffine3D ( InputArray src, InputArray dst, OutputArray outVal, OutputArray inliers, double ransacThreshold = 3, double confidence = 0.99 ) : int
src InputArray First input 3D point set.
dst InputArray Second input 3D point set.
outVal OutputArray Output 3D affine transformation matrix 3 x 4 .
inliers OutputArray Output vector indicating which points are inliers.
ransacThreshold double Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier.
confidence double 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.
return int

EstimateRigidTransform() public static method

Estimates the best-fit Euqcidean, similarity, affine or perspective transformation that maps one 2D point set to another or one image to another.
public static EstimateRigidTransform ( InputArray src, InputArray dst, bool fullAffine ) : OpenCvSharp.Mat
src InputArray First input 2D point set stored in std::vector or Mat, or an image stored in Mat.
dst InputArray Second input 2D point set of the same size and the same type as A, or another image.
fullAffine bool 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).
return OpenCvSharp.Mat

EvaluateFeatureDetector() public static method

public static EvaluateFeatureDetector ( OpenCvSharp.Mat img1, OpenCvSharp.Mat img2, OpenCvSharp.Mat H1to2, KeyPoint &keypoints1, KeyPoint &keypoints2, float &repeatability, int &correspCount ) : void
img1 OpenCvSharp.Mat
img2 OpenCvSharp.Mat
H1to2 OpenCvSharp.Mat
keypoints1 KeyPoint
keypoints2 KeyPoint
repeatability float
correspCount int
return void

Exp() public static method

computes exponent of each matrix element (dst = e**src)
public static Exp ( InputArray src, OutputArray dst ) : void
src InputArray The source array
dst OutputArray The destination array; will have the same size and same type as src
return void

ExtractChannel() public static method

extracts a single channel from src (coi is 0-based index)
public static ExtractChannel ( InputArray src, OutputArray dst, int coi ) : void
src InputArray
dst OutputArray
coi int
return void

FAST() public static method

Detects corners using the FAST algorithm
public static FAST ( InputArray image, int threshold, bool nonmaxSupression = true ) : KeyPoint[]
image InputArray grayscale image where keypoints (corners) are detected.
threshold int threshold on difference between intensity of the central pixel /// and pixels of a circle around this pixel.
nonmaxSupression bool if true, non-maximum suppression is applied to /// detected corners (keypoints).
return KeyPoint[]

FAST() public static method

Detects corners using the FAST algorithm
public static FAST ( InputArray image, int threshold, bool nonmaxSupression, FASTType type ) : KeyPoint[]
image InputArray grayscale image where keypoints (corners) are detected.
threshold int threshold on difference between intensity of the central pixel /// and pixels of a circle around this pixel.
nonmaxSupression bool if true, non-maximum suppression is applied to /// detected corners (keypoints).
type FASTType one of the three neighborhoods as defined in the paper
return KeyPoint[]

FastAtan2() public static method

computes the angle in degrees (0..360) of the vector (x,y)
public static FastAtan2 ( float y, float x ) : float
y float
x float
return float

FastFree() public static method

public static FastFree ( IntPtr ptr ) : void
ptr System.IntPtr
return void

FastMalloc() public static method

public static FastMalloc ( long bufSize ) : IntPtr
bufSize long
return System.IntPtr

FastNlMeansDenoising() public static method

Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations. Noise expected to be a gaussian white noise
public static FastNlMeansDenoising ( InputArray src, OutputArray dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
src InputArray Input 8-bit 1-channel, 2-channel or 3-channel image.
dst OutputArray Output image with the same size and type as src .
h float /// 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
templateWindowSize int /// Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int /// 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
return void

FastNlMeansDenoisingColored() public static method

Modification of fastNlMeansDenoising function for colored images
public static FastNlMeansDenoisingColored ( InputArray src, OutputArray dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
src InputArray Input 8-bit 3-channel image.
dst OutputArray Output image with the same size and type as src.
h float 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
hColor float 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
templateWindowSize int /// Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int /// 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
return void

FastNlMeansDenoisingColoredMulti() public static method

Modification of fastNlMeansDenoisingMulti function for colored images sequences
public static FastNlMeansDenoisingColoredMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
srcImgs IEnumerable Input 8-bit 3-channel images sequence. All images should have the same type and size.
dst OutputArray Output image with the same size and type as srcImgs images.
imgToDenoiseIndex int Target image to denoise index in srcImgs sequence
temporalWindowSize int 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.
h float 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.
hColor float The same as h but for color components.
templateWindowSize int Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int 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
return void

FastNlMeansDenoisingColoredMulti() public static method

Modification of fastNlMeansDenoisingMulti function for colored images sequences
public static FastNlMeansDenoisingColoredMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
srcImgs IEnumerable Input 8-bit 3-channel images sequence. All images should have the same type and size.
dst OutputArray Output image with the same size and type as srcImgs images.
imgToDenoiseIndex int Target image to denoise index in srcImgs sequence
temporalWindowSize int 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.
h float 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.
hColor float The same as h but for color components.
templateWindowSize int Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int 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
return void

FastNlMeansDenoisingMulti() public static method

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.
public static FastNlMeansDenoisingMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
srcImgs IEnumerable Input 8-bit 1-channel, 2-channel or 3-channel images sequence. All images should have the same type and size.
dst OutputArray Output image with the same size and type as srcImgs images.
imgToDenoiseIndex int Target image to denoise index in srcImgs sequence
temporalWindowSize int 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.
h float 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
templateWindowSize int Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int 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
return void

FastNlMeansDenoisingMulti() public static method

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.
public static FastNlMeansDenoisingMulti ( IEnumerable srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21 ) : void
srcImgs IEnumerable Input 8-bit 1-channel, 2-channel or 3-channel images sequence. All images should have the same type and size.
dst OutputArray Output image with the same size and type as srcImgs images.
imgToDenoiseIndex int Target image to denoise index in srcImgs sequence
temporalWindowSize int 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.
h float 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
templateWindowSize int Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize int 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
return void

FillConvexPoly() public static method

Fills a convex polygon.
public static FillConvexPoly ( OpenCvSharp.InputOutputArray img, InputArray pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift ) : void
img OpenCvSharp.InputOutputArray Image
pts InputArray The polygon vertices
color Scalar Polygon color
lineType LineTypes Type of the polygon boundaries
shift int The number of fractional bits in the vertex coordinates
return void

FillConvexPoly() public static method

Fills a convex polygon.
public static FillConvexPoly ( OpenCvSharp.Mat img, IEnumerable pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift ) : void
img OpenCvSharp.Mat Image
pts IEnumerable The polygon vertices
color Scalar Polygon color
lineType LineTypes Type of the polygon boundaries
shift int The number of fractional bits in the vertex coordinates
return void

FillPoly() public static method

Fills the area bounded by one or more polygons
public static FillPoly ( OpenCvSharp.InputOutputArray img, InputArray pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift, System.Point offset = null ) : void
img OpenCvSharp.InputOutputArray Image
pts InputArray Array of polygons, each represented as an array of points
color Scalar Polygon color
lineType LineTypes Type of the polygon boundaries
shift int The number of fractional bits in the vertex coordinates
offset System.Point
return void

FillPoly() public static method

Fills the area bounded by one or more polygons
public static FillPoly ( OpenCvSharp.Mat img, IEnumerable pts, Scalar color, LineTypes lineType = LineTypes.Link8, int shift, System.Point offset = null ) : void
img OpenCvSharp.Mat Image
pts IEnumerable Array of polygons, each represented as an array of points
color Scalar Polygon color
lineType LineTypes Type of the polygon boundaries
shift int The number of fractional bits in the vertex coordinates
offset System.Point
return void

Filter2D() public static method

Convolves an image with the kernel
public static Filter2D ( InputArray src, OutputArray dst, MatType ddepth, InputArray kernel, System.Point anchor = null, double delta, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image. It will have the same size and the same number of channels as src
ddepth MatType The desired depth of the destination image. If it is negative, it will be the same as src.depth()
kernel InputArray 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
anchor System.Point 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
delta double The optional value added to the filtered pixels before storing them in dst
borderType BorderTypes The pixel extrapolation method
return void

FilterSpeckles() public static method

filters off speckles (small regions of incorrectly computed disparity)
public static FilterSpeckles ( OpenCvSharp.InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, OpenCvSharp.InputOutputArray buf = null ) : void
img OpenCvSharp.InputOutputArray The input 16-bit signed disparity image
newVal double The disparity value used to paint-off the speckles
maxSpeckleSize int The maximum speckle size to consider it a speckle. Larger blobs are not affected by the algorithm
maxDiff double 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.
buf OpenCvSharp.InputOutputArray The optional temporary buffer to avoid memory allocation within the function.
return void

Find4QuadCornerSubpix() public static method

finds subpixel-accurate positions of the chessboard corners
public static Find4QuadCornerSubpix ( InputArray img, OpenCvSharp.InputOutputArray corners, Size regionSize ) : bool
img InputArray
corners OpenCvSharp.InputOutputArray
regionSize Size
return bool

Find4QuadCornerSubpix() public static method

finds subpixel-accurate positions of the chessboard corners
public static Find4QuadCornerSubpix ( InputArray img, [ corners, Size regionSize ) : bool
img InputArray
corners [
regionSize Size
return bool

FindChessboardCorners() public static method

Finds the positions of internal corners of the chessboard.
public static FindChessboardCorners ( InputArray image, Size patternSize, OutputArray corners, ChessboardFlags flags = ChessboardFlags.AdaptiveThresh|ChessboardFlags.NormalizeImage ) : bool
image InputArray Source chessboard view. It must be an 8-bit grayscale or color image.
patternSize Size Number of inner corners per a chessboard row and column /// ( patternSize = Size(points_per_row,points_per_colum) = Size(columns, rows) ).
corners OutputArray Output array of detected corners.
flags ChessboardFlags Various operation flags that can be zero or a combination of the ChessboardFlag values
return bool

FindChessboardCorners() public static method

Finds the positions of internal corners of the chessboard.
public static FindChessboardCorners ( InputArray image, Size patternSize, Point2f &corners, ChessboardFlags flags = ChessboardFlags.AdaptiveThresh|ChessboardFlags.NormalizeImage ) : bool
image InputArray Source chessboard view. It must be an 8-bit grayscale or color image.
patternSize Size Number of inner corners per a chessboard row and column /// ( patternSize = Size(points_per_row,points_per_colum) = Size(columns, rows) ).
corners Point2f Output array of detected corners.
flags ChessboardFlags Various operation flags that can be zero or a combination of the ChessboardFlag values
return bool

FindCirclesGrid() public static method

Finds centers in the grid of circles.
public static FindCirclesGrid ( InputArray image, Size patternSize, OutputArray centers, FindCirclesGridFlags flags = FindCirclesGridFlags.SymmetricGrid, FeatureDetector blobDetector = null ) : bool
image InputArray grid view of input circles; it must be an 8-bit grayscale or color image.
patternSize Size number of circles per row and column ( patternSize = Size(points_per_row, points_per_colum) ).
centers OutputArray output array of detected centers.
flags FindCirclesGridFlags various operation flags that can be one of the FindCirclesGridFlag values
blobDetector FeatureDetector feature detector that finds blobs like dark circles on light background.
return bool

FindCirclesGrid() public static method

Finds centers in the grid of circles.
public static FindCirclesGrid ( InputArray image, Size patternSize, Point2f &centers, FindCirclesGridFlags flags = FindCirclesGridFlags.SymmetricGrid, FeatureDetector blobDetector = null ) : bool
image InputArray grid view of input circles; it must be an 8-bit grayscale or color image.
patternSize Size number of circles per row and column ( patternSize = Size(points_per_row, points_per_colum) ).
centers Point2f output array of detected centers.
flags FindCirclesGridFlags various operation flags that can be one of the FindCirclesGridFlag values
blobDetector FeatureDetector feature detector that finds blobs like dark circles on light background.
return bool

FindContours() public static method

Finds contours in a binary image.
public static FindContours ( InputOutputArray image, Mat &contours, OutputArray hierarchy, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : void
image InputOutputArray 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.
contours Mat Detected contours. Each contour is stored as a vector of points.
hierarchy OutputArray 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.
mode RetrievalModes Contour retrieval mode
method ContourApproximationModes Contour approximation method
offset Point 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.
return void

FindContours() public static method

Finds contours in a binary image.
public static FindContours ( InputOutputArray image, Point &contours, HierarchyIndex &hierarchy, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : void
image InputOutputArray 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.
contours Point Detected contours. Each contour is stored as a vector of points.
hierarchy HierarchyIndex 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.
mode RetrievalModes Contour retrieval mode
method ContourApproximationModes Contour approximation method
offset Point 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.
return void

FindContoursAsArray() public static method

Finds contours in a binary image.
public static FindContoursAsArray ( InputOutputArray image, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : Point[][]
image InputOutputArray 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.
mode RetrievalModes Contour retrieval mode
method ContourApproximationModes Contour approximation method
offset Point 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.
return Point[][]

FindContoursAsMat() public static method

Finds contours in a binary image.
public static FindContoursAsMat ( InputOutputArray image, RetrievalModes mode, ContourApproximationModes method, Point offset = null ) : MatOfPoint[]
image InputOutputArray 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.
mode RetrievalModes Contour retrieval mode
method ContourApproximationModes Contour approximation method
offset Point 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.
return MatOfPoint[]

FindFundamentalMat() public static method

Calculates a fundamental matrix from the corresponding points in two images.
public static FindFundamentalMat ( IEnumerable points1, IEnumerable points2, FundamentalMatMethod method = FundamentalMatMethod.Ransac, double param1 = 3.0, double param2 = 0.99, OutputArray mask = null ) : Mat
points1 IEnumerable Array of N points from the first image. /// The point coordinates should be floating-point (single or double precision).
points2 IEnumerable Array of the second image points of the same size and format as points1 .
method FundamentalMatMethod Method for computing a fundamental matrix.
param1 double 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.
param2 double Parameter used for the RANSAC or LMedS methods only. /// It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
mask OutputArray 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.
return Mat

FindFundamentalMat() public static method

Calculates a fundamental matrix from the corresponding points in two images.
public static FindFundamentalMat ( InputArray points1, InputArray points2, FundamentalMatMethod method = FundamentalMatMethod.Ransac, double param1 = 3.0, double param2 = 0.99, OutputArray mask = null ) : Mat
points1 InputArray Array of N points from the first image. /// The point coordinates should be floating-point (single or double precision).
points2 InputArray Array of the second image points of the same size and format as points1 .
method FundamentalMatMethod Method for computing a fundamental matrix.
param1 double 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.
param2 double Parameter used for the RANSAC or LMedS methods only. /// It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
mask OutputArray 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.
return Mat

FindHomography() public static method

computes the best-fit perspective transformation mapping srcPoints to dstPoints.
public static FindHomography ( IEnumerable srcPoints, IEnumerable dstPoints, HomographyMethods method = HomographyMethods.None, double ransacReprojThreshold = 3, OutputArray mask = null ) : Mat
srcPoints IEnumerable Coordinates of the points in the original plane
dstPoints IEnumerable Coordinates of the points in the target plane
method HomographyMethods Method used to computed a homography matrix.
ransacReprojThreshold double Maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only)
mask OutputArray Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored.
return Mat

FindHomography() public static method

computes the best-fit perspective transformation mapping srcPoints to dstPoints.
public static FindHomography ( InputArray srcPoints, InputArray dstPoints, HomographyMethods method = HomographyMethods.None, double ransacReprojThreshold = 3, OutputArray mask = null ) : Mat
srcPoints InputArray Coordinates of the points in the original plane, a matrix of the type CV_32FC2
dstPoints InputArray Coordinates of the points in the target plane, a matrix of the type CV_32FC2
method HomographyMethods Method used to computed a homography matrix.
ransacReprojThreshold double Maximum allowed reprojection error to treat a point pair as an inlier (used in the RANSAC method only)
mask OutputArray Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored.
return Mat

FindNonZero() public static method

returns the list of locations of non-zero pixels
public static FindNonZero ( InputArray src, OutputArray idx ) : void
src InputArray
idx OutputArray
return void

FitEllipse() public static method

Fits ellipse to the set of 2D points.
public static FitEllipse ( IEnumerable points ) : RotatedRect
points IEnumerable Input 2D point set
return RotatedRect

FitEllipse() public static method

Fits ellipse to the set of 2D points.
public static FitEllipse ( IEnumerable points ) : RotatedRect
points IEnumerable Input 2D point set
return RotatedRect

FitEllipse() public static method

Fits ellipse to the set of 2D points.
public static FitEllipse ( InputArray points ) : RotatedRect
points InputArray Input 2D point set
return RotatedRect

FitLine() public static method

Fits line to the set of 2D points using M-estimator algorithm
public static FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line2D
points IEnumerable Input vector of 2D or 3D points
distType DistanceTypes Distance used by the M-estimator
param double Numerical parameter ( C ) for some types of distances. /// If it is 0, an optimal value is chosen.
reps double Sufficient accuracy for the radius /// (distance between the coordinate origin and the line).
aeps double Sufficient accuracy for the angle. /// 0.01 would be a good default value for reps and aeps.
return Line2D

FitLine() public static method

Fits line to the set of 2D points using M-estimator algorithm
public static FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line2D
points IEnumerable Input vector of 2D or 3D points
distType DistanceTypes Distance used by the M-estimator
param double Numerical parameter ( C ) for some types of distances. /// If it is 0, an optimal value is chosen.
reps double Sufficient accuracy for the radius /// (distance between the coordinate origin and the line).
aeps double Sufficient accuracy for the angle. /// 0.01 would be a good default value for reps and aeps.
return Line2D

FitLine() public static method

Fits line to the set of 3D points using M-estimator algorithm
public static FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line3D
points IEnumerable Input vector of 2D or 3D points
distType DistanceTypes Distance used by the M-estimator
param double Numerical parameter ( C ) for some types of distances. /// If it is 0, an optimal value is chosen.
reps double Sufficient accuracy for the radius /// (distance between the coordinate origin and the line).
aeps double Sufficient accuracy for the angle. /// 0.01 would be a good default value for reps and aeps.
return Line3D

FitLine() public static method

Fits line to the set of 3D points using M-estimator algorithm
public static FitLine ( IEnumerable points, DistanceTypes distType, double param, double reps, double aeps ) : Line3D
points IEnumerable Input vector of 2D or 3D points
distType DistanceTypes Distance used by the M-estimator
param double Numerical parameter ( C ) for some types of distances. /// If it is 0, an optimal value is chosen.
reps double Sufficient accuracy for the radius /// (distance between the coordinate origin and the line).
aeps double Sufficient accuracy for the angle. /// 0.01 would be a good default value for reps and aeps.
return Line3D

FitLine() public static method

Fits line to the set of 2D points using M-estimator algorithm
public static FitLine ( InputArray points, OutputArray line, DistanceTypes distType, double param, double reps, double aeps ) : void
points InputArray Input vector of 2D or 3D points
line OutputArray 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.
distType DistanceTypes Distance used by the M-estimator
param double Numerical parameter ( C ) for some types of distances. /// If it is 0, an optimal value is chosen.
reps double Sufficient accuracy for the radius /// (distance between the coordinate origin and the line).
aeps double Sufficient accuracy for the angle. /// 0.01 would be a good default value for reps and aeps.
return void

Flip() public static method

reverses the order of the rows, columns or both in a matrix
public static Flip ( InputArray src, OutputArray dst, FlipMode flipCode ) : void
src InputArray The source array
dst OutputArray The destination array; will have the same size and same type as src
flipCode FlipMode 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.
return void

FloodFill() public static method

Fills a connected component with the given color.
public static FloodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal ) : int
image InputOutputArray 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.
mask InputOutputArray (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.
seedPoint Point Starting point.
newVal Scalar New value of the repainted domain pixels.
return int

FloodFill() public static method

Fills a connected component with the given color.
public static FloodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect &rect, Scalar loDiff = null, Scalar upDiff = null, FloodFillFlags flags = FloodFillFlags.Link4 ) : int
image InputOutputArray 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.
mask InputOutputArray (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.
seedPoint Point Starting point.
newVal Scalar New value of the repainted domain pixels.
rect Rect Optional output parameter set by the function to the /// minimum bounding rectangle of the repainted domain.
loDiff Scalar 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.
upDiff Scalar 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.
flags FloodFillFlags 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.
return int

FloodFill() public static method

Fills a connected component with the given color.
public static FloodFill ( InputOutputArray image, Point seedPoint, Scalar newVal ) : int
image InputOutputArray 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.
seedPoint Point Starting point.
newVal Scalar New value of the repainted domain pixels.
return int

FloodFill() public static method

Fills a connected component with the given color.
public static FloodFill ( InputOutputArray image, Point seedPoint, Scalar newVal, Rect &rect, Scalar loDiff = null, Scalar upDiff = null, FloodFillFlags flags = FloodFillFlags.Link4 ) : int
image InputOutputArray 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.
seedPoint Point Starting point.
newVal Scalar New value of the repainted domain pixels.
rect Rect Optional output parameter set by the function to the /// minimum bounding rectangle of the repainted domain.
loDiff Scalar 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.
upDiff Scalar 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.
flags FloodFillFlags 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.
return int

GaussianBlur() public static method

Blurs an image using a Gaussian filter.
public static GaussianBlur ( InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray 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.
dst OutputArray output image of the same size and type as src.
ksize Size 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* .
sigmaX double Gaussian kernel standard deviation in X direction.
sigmaY double 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.
borderType BorderTypes pixel extrapolation method
return void

Gemm() public static method

implements generalized matrix product algorithm GEMM from BLAS
public static Gemm ( InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, GemmFlags flags = GemmFlags.None ) : void
src1 InputArray
src2 InputArray
alpha double
src3 InputArray
gamma double
dst OutputArray
flags GemmFlags
return void

GetAffineTransform() public static method

public static GetAffineTransform ( IEnumerable src, IEnumerable dst ) : Mat
src IEnumerable
dst IEnumerable
return Mat

GetAffineTransform() public static method

public static GetAffineTransform ( InputArray src, InputArray dst ) : Mat
src InputArray
dst InputArray
return Mat

GetBuildInformation() public static method

public static GetBuildInformation ( ) : string
return string

GetCpuTickCount() public static method

public static GetCpuTickCount ( ) : long
return long

GetDefaultNewCameraMatrix() public static method

returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
public static GetDefaultNewCameraMatrix ( InputArray cameraMatrix, Size imgSize = null, bool centerPrincipalPoint = false ) : Mat
cameraMatrix InputArray Input camera matrix.
imgSize Size Camera view image size in pixels.
centerPrincipalPoint bool Location of the principal point in the new camera matrix. /// The parameter indicates whether this location should be at the image center or not.
return Mat

GetDerivKernels() public static method

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

GetGaborKernel() public static method

public static GetGaborKernel ( Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype ) : Mat
ksize Size
sigma double
theta double
lambd double
gamma double
psi double
ktype int
return Mat

GetGaussianKernel() public static method

Returns Gaussian filter coefficients.
public static GetGaussianKernel ( int ksize, double sigma, MatType ktype = null ) : Mat
ksize int Aperture size. It should be odd and positive.
sigma double Gaussian standard deviation. /// If it is non-positive, it is computed from ksize as `sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8`.
ktype MatType Type of filter coefficients. It can be CV_32F or CV_64F.
return Mat

GetNearestPoint() public static method

public static GetNearestPoint ( IEnumerable recallPrecisionCurve, float lPrecision ) : int
recallPrecisionCurve IEnumerable
lPrecision float
return int

GetNumThreads() public static method

public static GetNumThreads ( ) : int
return int

GetNumberOfCpus() public static method

public static GetNumberOfCpus ( ) : int
return int

GetOptimalDFTSize() public static method

computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
public static GetOptimalDFTSize ( int vecsize ) : int
vecsize int
return int

GetOptimalNewCameraMatrix() public static method

Returns the new camera matrix based on the free scaling parameter.
public static GetOptimalNewCameraMatrix ( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect &validPixROI, bool centerPrincipalPoint = false ) : Mat
cameraMatrix InputArray Input camera matrix.
distCoeffs InputArray 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.
imageSize Size Original image size.
alpha double 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).
newImgSize Size Image size after rectification. By default,it is set to imageSize .
validPixROI Rect Optional output rectangle that outlines all-good-pixels region in the undistorted image. See roi1, roi2 description in stereoRectify() .
centerPrincipalPoint bool 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.
return Mat

GetOptimalNewCameraMatrix() public static method

Returns the new camera matrix based on the free scaling parameter.
public static GetOptimalNewCameraMatrix ( double cameraMatrix, double distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect &validPixROI, bool centerPrincipalPoint = false ) : ].double[
cameraMatrix double Input camera matrix.
distCoeffs double 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.
imageSize Size Original image size.
alpha double 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).
newImgSize Size Image size after rectification. By default,it is set to imageSize .
validPixROI Rect Optional output rectangle that outlines all-good-pixels region in the undistorted image. See roi1, roi2 description in stereoRectify() .
centerPrincipalPoint bool 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.
return ].double[

GetPerspectiveTransform() public static method

public static GetPerspectiveTransform ( IEnumerable src, IEnumerable dst ) : Mat
src IEnumerable
dst IEnumerable
return Mat

GetPerspectiveTransform() public static method

public static GetPerspectiveTransform ( InputArray src, InputArray dst ) : Mat
src InputArray
dst InputArray
return Mat

GetRecall() public static method

public static GetRecall ( IEnumerable recallPrecisionCurve, float lPrecision ) : float
recallPrecisionCurve IEnumerable
lPrecision float
return float

GetRectSubPix() public static method

Retrieves a pixel rectangle from an image with sub-pixel accuracy.
public static GetRectSubPix ( InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType = -1 ) : void
image InputArray Source image.
patchSize Size Size of the extracted patch.
center Point2f Floating point coordinates of the center of the extracted rectangle /// within the source image. The center must be inside the image.
patch OutputArray Extracted patch that has the size patchSize and the same number of channels as src .
patchType int Depth of the extracted pixels. By default, they have the same depth as src.
return void

GetRotationMatrix2D() public static method

public static GetRotationMatrix2D ( Point2f center, double angle, double scale ) : Mat
center Point2f
angle double
scale double
return Mat

GetStructuringElement() public static method

public static GetStructuringElement ( MorphShapes shape, Size ksize ) : Mat
shape MorphShapes
ksize Size
return Mat

GetStructuringElement() public static method

public static GetStructuringElement ( MorphShapes shape, Size ksize, Point anchor ) : Mat
shape MorphShapes
ksize Size
anchor Point
return Mat

GetTextSize() public static method

returns bounding box of the text string
public static GetTextSize ( string text, HersheyFonts fontFace, double fontScale, int thickness, int &baseLine ) : Size
text string
fontFace HersheyFonts
fontScale double
thickness int
baseLine int
return Size

GetThreadNum() public static method

public static GetThreadNum ( ) : int
return int

GetTickCount() public static method

public static GetTickCount ( ) : long
return long

GetTickFrequency() public static method

public static GetTickFrequency ( ) : double
return double

GetValidDisparityROI() public static method

computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
public static GetValidDisparityROI ( Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize ) : Rect
roi1 Rect
roi2 Rect
minDisparity int
numberOfDisparities int
SADWindowSize int
return Rect

GetWindowProperty() public static method

Provides parameters of a window.
public static GetWindowProperty ( string winName, WindowProperty propId ) : double
winName string Name of the window.
propId WindowProperty Window property to retrieve.
return double

GoodFeaturesToTrack() public static method

finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
public static GoodFeaturesToTrack ( InputArray src, int maxCorners, double qualityLevel, double minDistance, InputArray mask, int blockSize, bool useHarrisDetector, double k ) : Point2f[]
src InputArray Input 8-bit or floating-point 32-bit, single-channel image.
maxCorners int Maximum number of corners to return. If there are more corners than are found, /// the strongest of them is returned.
qualityLevel double 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.
minDistance double Minimum possible Euclidean distance between the returned corners.
mask InputArray 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.
blockSize int Size of an average block for computing a derivative covariation matrix over each pixel neighborhood.
useHarrisDetector bool Parameter indicating whether to use a Harris detector
k double Free parameter of the Harris detector.
return Point2f[]

GrabCut() public static method

Segments the image using GrabCut algorithm
public static GrabCut ( InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, GrabCutModes mode ) : void
img InputArray Input 8-bit 3-channel image.
mask InputOutputArray 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
rect Rect 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.
bgdModel InputOutputArray Temporary array for the background model. Do not modify it while you are processing the same image.
fgdModel InputOutputArray Temporary arrays for the foreground model. Do not modify it while you are processing the same image.
iterCount int 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 .
mode GrabCutModes Operation mode that could be one of GrabCutFlag value.
return void

HConcat() public static method

public static HConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void
src1 InputArray
src2 InputArray
dst OutputArray
return void

HConcat() public static method

public static HConcat ( Mat src, OutputArray dst ) : void
src Mat
dst OutputArray
return void

HaveImageReader() public static method

public static HaveImageReader ( string fileName ) : bool
fileName string
return bool

HaveImageWriter() public static method

public static HaveImageWriter ( string fileName ) : bool
fileName string
return bool

HoughCircles() public static method

Finds circles in a grayscale image using a Hough transform.
public static HoughCircles ( InputArray image, HoughMethods method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius, int maxRadius ) : CircleSegment[]
image InputArray The 8-bit, single-channel, grayscale input image
method HoughMethods Currently, the only implemented method is HoughCirclesMethod.Gradient
dp double The inverse ratio of the accumulator resolution to the image resolution.
minDist double Minimum distance between the centers of the detected circles.
param1 double The first method-specific parameter. [By default this is 100]
param2 double The second method-specific parameter. [By default this is 100]
minRadius int Minimum circle radius. [By default this is 0]
maxRadius int Maximum circle radius. [By default this is 0]
return CircleSegment[]

HoughLines() public static method

Finds lines in a binary image using standard Hough transform.
public static HoughLines ( InputArray image, double rho, double theta, int threshold, double srn, double stn ) : LineSegmentPolar[]
image InputArray The 8-bit, single-channel, binary source image. The image may be modified by the function
rho double Distance resolution of the accumulator in pixels
theta double Angle resolution of the accumulator in radians
threshold int The accumulator threshold parameter. Only those lines are returned that get enough votes ( > threshold )
srn double For the multi-scale Hough transform it is the divisor for the distance resolution rho. [By default this is 0]
stn double For the multi-scale Hough transform it is the divisor for the distance resolution theta. [By default this is 0]
return LineSegmentPolar[]

HoughLinesP() public static method

Finds lines segments in a binary image using probabilistic Hough transform.
public static HoughLinesP ( InputArray image, double rho, double theta, int threshold, double minLineLength, double maxLineGap ) : LineSegmentPoint[]
image InputArray
rho double Distance resolution of the accumulator in pixels
theta double Angle resolution of the accumulator in radians
threshold int The accumulator threshold parameter. Only those lines are returned that get enough votes ( > threshold )
minLineLength double The minimum line length. Line segments shorter than that will be rejected. [By default this is 0]
maxLineGap double The maximum allowed gap between points on the same line to link them. [By default this is 0]
return LineSegmentPoint[]

Idct() public static method

Performs inverse 1D or 2D Discrete Cosine Transformation
public static Idct ( InputArray src, OutputArray dst, DctFlags flags = DctFlags.None ) : void
src InputArray The source floating-point array
dst OutputArray The destination array; will have the same size and same type as src
flags DctFlags Transformation flags, a combination of DctFlag2 values
return void

Idft() public static method

Performs an inverse Discrete Fourier transform of 1D or 2D floating-point array.
public static Idft ( InputArray src, OutputArray dst, DftFlags flags = DftFlags.None, int nonzeroRows ) : void
src InputArray The source array, real or complex
dst OutputArray The destination array, which size and type depends on the flags
flags DftFlags Transformation flags, a combination of the DftFlag2 values
nonzeroRows int 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
return void

IlluminationChange() public static method

Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.
This is useful to highlight under-exposed foreground objects or to reduce specular reflections.
public static IlluminationChange ( InputArray src, InputArray mask, OutputArray dst, float alpha = 0.2f, float beta = 0.4f ) : void
src InputArray Input 8-bit 3-channel image.
mask InputArray Input 8-bit 1 or 3-channel image.
dst OutputArray Output image with the same size and type as src.
alpha float Value ranges between 0-2.
beta float Value ranges between 0-2.
return void

ImDecode() public static method

Reads image from the specified buffer in memory.
public static ImDecode ( InputArray buf, ImreadModes flags ) : Mat
buf InputArray The input array of vector of bytes.
flags ImreadModes The same flags as in imread
return Mat

ImDecode() public static method

Reads image from the specified buffer in memory.
public static ImDecode ( Mat buf, ImreadModes flags ) : Mat
buf Mat The input array of vector of bytes.
flags ImreadModes The same flags as in imread
return Mat

ImDecode() public static method

Reads image from the specified buffer in memory.
public static ImDecode ( byte buf, ImreadModes flags ) : Mat
buf byte The input array of vector of bytes.
flags ImreadModes The same flags as in imread
return Mat

ImEncode() public static method

Compresses the image and stores it in the memory buffer
public static ImEncode ( string ext, InputArray img, byte &buf, int prms = null ) : bool
ext string The file extension that defines the output format
img InputArray The image to be written
buf byte Output buffer resized to fit the compressed image.
prms int Format-specific parameters.
return bool

ImEncode() public static method

Compresses the image and stores it in the memory buffer
public static ImEncode ( string ext, InputArray img, byte &buf ) : void
ext string The file extension that defines the output format
img InputArray The image to be written
buf byte Output buffer resized to fit the compressed image.
return void

ImRead() public static method

Loads an image from a file.
public static ImRead ( string fileName, ImreadModes flags = ImreadModes.Color ) : Mat
fileName string Name of file to be loaded.
flags ImreadModes Specifies color type of the loaded image
return Mat

ImReadMulti() public static method

Loads a multi-page image from a file.
public static ImReadMulti ( string filename, Mat &mats, ImreadModes flags = ImreadModes.AnyColor ) : bool
filename string Name of file to be loaded.
mats Mat A vector of Mat objects holding each page, if more than one.
flags ImreadModes Flag that can take values of @ref cv::ImreadModes, default with IMREAD_ANYCOLOR.
return bool

ImShow() public static method

Displays the image in the specified window
public static ImShow ( string winname, Mat mat ) : void
winname string Name of the window.
mat Mat Image to be shown.
return void

ImWrite() public static method

Saves an image to a specified file.
public static ImWrite ( string fileName, Mat img ) : bool
fileName string Name of the file.
img Mat Image to be saved.
return bool

ImWrite() public static method

Saves an image to a specified file.
public static ImWrite ( string fileName, Mat img, int prms = null ) : bool
fileName string Name of the file.
img Mat Image to be saved.
prms int Format-specific save parameters encoded as pairs
return bool

InRange() public static method

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
public static InRange ( InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst ) : void
src InputArray The first source array
lowerb InputArray The inclusive lower boundary array of the same size and type as src
upperb InputArray The exclusive upper boundary array of the same size and type as src
dst OutputArray The destination array, will have the same size as src and CV_8U type
return void

InRange() public static method

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
public static InRange ( InputArray src, Scalar lowerb, Scalar upperb, OutputArray dst ) : void
src InputArray The first source array
lowerb Scalar The inclusive lower boundary array of the same size and type as src
upperb Scalar The exclusive upper boundary array of the same size and type as src
dst OutputArray The destination array, will have the same size as src and CV_8U type
return void

InitCameraMatrix2D() public static method

initializes camera matrix from a few 3D points and the corresponding projections.
public static InitCameraMatrix2D ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double aspectRatio = 1.0 ) : Mat
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
imageSize Size Image size in pixels used to initialize the principal point.
aspectRatio double If it is zero or negative, both f_x and f_y are estimated independently. Otherwise, f_x = f_y * aspectRatio .
return Mat

InitCameraMatrix2D() public static method

initializes camera matrix from a few 3D points and the corresponding projections.
public static InitCameraMatrix2D ( IEnumerable objectPoints, IEnumerable imagePoints, Size imageSize, double aspectRatio = 1.0 ) : Mat
objectPoints IEnumerable 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.
imagePoints IEnumerable Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated.
imageSize Size Image size in pixels used to initialize the principal point.
aspectRatio double If it is zero or negative, both f_x and f_y are estimated independently. Otherwise, f_x = f_y * aspectRatio .
return Mat

InitUndistortRectifyMap() public static method

initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
public static InitUndistortRectifyMap ( InputArray cameraMatrix, InputArray distCoeffs, InputArray r, InputArray newCameraMatrix, Size size, MatType m1Type, OutputArray map1, OutputArray map2 ) : void
cameraMatrix InputArray
distCoeffs InputArray
r InputArray
newCameraMatrix InputArray
size Size
m1Type MatType
map1 OutputArray
map2 OutputArray
return void

InitWideAngleProjMap() public static method

initializes maps for cv::remap() for wide-angle
public static InitWideAngleProjMap ( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, MatType m1Type, OutputArray map1, OutputArray map2, ProjectionType projType, double alpha ) : float
cameraMatrix InputArray
distCoeffs InputArray
imageSize Size
destImageWidth int
m1Type MatType
map1 OutputArray
map2 OutputArray
projType ProjectionType
alpha double
return float

Inpaint() public static method

restores the damaged image areas using one of the available intpainting algorithms
public static Inpaint ( InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, InpaintMethod flags ) : void
src InputArray
inpaintMask InputArray
dst OutputArray
inpaintRadius double
flags InpaintMethod
return void

InsertChannel() public static method

inserts a single channel to dst (coi is 0-based index)
public static InsertChannel ( InputArray src, InputOutputArray dst, int coi ) : void
src InputArray
dst InputOutputArray
coi int
return void

Integral() public static method

public static Integral ( InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth = -1 ) : void
src InputArray
sum OutputArray
sqsum OutputArray
tilted OutputArray
sdepth int
return void

Integral() public static method

public static Integral ( InputArray src, OutputArray sum, OutputArray sqsum, int sdepth = -1 ) : void
src InputArray
sum OutputArray
sqsum OutputArray
sdepth int
return void

Integral() public static method

public static Integral ( InputArray src, OutputArray sum, int sdepth = -1 ) : void
src InputArray
sum OutputArray
sdepth int
return void

IntersectConvexConvex() public static method

finds intersection of two convex polygons
public static IntersectConvexConvex ( IEnumerable p1, IEnumerable p2, Point2f &p12, bool handleNested = true ) : float
p1 IEnumerable
p2 IEnumerable
p12 Point2f
handleNested bool
return float

IntersectConvexConvex() public static method

finds intersection of two convex polygons
public static IntersectConvexConvex ( IEnumerable p1, IEnumerable p2, Point &p12, bool handleNested = true ) : float
p1 IEnumerable
p2 IEnumerable
p12 Point
handleNested bool
return float

IntersectConvexConvex() public static method

finds intersection of two convex polygons
public static IntersectConvexConvex ( InputArray p1, InputArray p2, OutputArray p12, bool handleNested = true ) : float
p1 InputArray
p2 InputArray
p12 OutputArray
handleNested bool
return float

Invert() public static method

computes inverse or pseudo-inverse matrix
public static Invert ( InputArray src, OutputArray dst, DecompTypes flags = DecompTypes.LU ) : double
src InputArray The source floating-point MxN matrix
dst OutputArray The destination matrix; will have NxM size and the same type as src
flags DecompTypes The inversion method
return double

InvertAffineTransform() public static method

Inverts an affine transformation.
public static InvertAffineTransform ( InputArray m, OutputArray im ) : void
m InputArray Original affine transformation.
im OutputArray Output reverse affine transformation.
return void

IsContourConvex() public static method

returns true if the contour is convex. D oes not support contours with self-intersection
public static IsContourConvex ( IEnumerable contour ) : bool
contour IEnumerable Input vector of 2D points
return bool

IsContourConvex() public static method

returns true if the contour is convex. Does not support contours with self-intersection
public static IsContourConvex ( IEnumerable contour ) : bool
contour IEnumerable Input vector of 2D points
return bool

IsContourConvex() public static method

returns true if the contour is convex. Does not support contours with self-intersection
public static IsContourConvex ( InputArray contour ) : bool
contour InputArray Input vector of 2D points
return bool

Kmeans() public static method

clusters the input data using k-Means algorithm
public static Kmeans ( InputArray data, int k, InputOutputArray bestLabels, TermCriteria criteria, int attempts, KMeansFlags flags, OutputArray centers = null ) : double
data InputArray
k int
bestLabels InputOutputArray
criteria TermCriteria
attempts int
flags KMeansFlags
centers OutputArray
return double

LUT() public static method

transforms array of numbers using a lookup table: dst(i)=lut(src(i))
public static LUT ( InputArray src, InputArray lut, OutputArray dst, int interpolation ) : void
src InputArray Source array of 8-bit elements
lut InputArray 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
dst OutputArray Destination array; /// will have the same size and the same number of channels as src, /// and the same depth as lut
interpolation int
return void

LUT() public static method

transforms array of numbers using a lookup table: dst(i)=lut(src(i))
public static LUT ( InputArray src, byte lut, OutputArray dst, int interpolation ) : void
src InputArray Source array of 8-bit elements
lut byte 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
dst OutputArray Destination array; /// will have the same size and the same number of channels as src, /// and the same depth as lut
interpolation int
return void

Laplacian() public static method

Calculates the Laplacian of an image
public static Laplacian ( InputArray src, OutputArray dst, MatType ddepth, int ksize = 1, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray Source image
dst OutputArray Destination image; will have the same size and the same number of channels as src
ddepth MatType The desired depth of the destination image
ksize int The aperture size used to compute the second-derivative filters
scale double The optional scale factor for the computed Laplacian values (by default, no scaling is applied
delta double The optional delta value, added to the results prior to storing them in dst
borderType BorderTypes The pixel extrapolation method
return void

Line() public static method

Draws a line segment connecting two points
public static Line ( InputOutputArray img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img InputOutputArray The image.
pt1 Point First point of the line segment.
pt2 Point Second point of the line segment.
color Scalar Line color.
thickness int Line thickness. [By default this is 1]
lineType LineTypes Type of the line. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

Line() public static method

Draws a line segment connecting two points
public static Line ( InputOutputArray img, int pt1X, int pt1Y, int pt2X, int pt2Y, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img InputOutputArray The image.
pt1X int First point's x-coordinate of the line segment.
pt1Y int First point's y-coordinate of the line segment.
pt2X int Second point's x-coordinate of the line segment.
pt2Y int Second point's y-coordinate of the line segment.
color Scalar Line color.
thickness int Line thickness. [By default this is 1]
lineType LineTypes Type of the line. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

LinearPolar() public static method

Remaps an image to polar space.
public static LinearPolar ( InputArray src, OutputArray dst, Point2f center, double maxRadius, InterpolationFlags flags ) : void
src InputArray Source image
dst OutputArray Destination image
center Point2f The transformation center
maxRadius double Inverse magnitude scale parameter
flags InterpolationFlags A combination of interpolation methods, see cv::InterpolationFlags
return void

Log() public static method

computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
public static Log ( InputArray src, OutputArray dst ) : void
src InputArray The source array
dst OutputArray The destination array; will have the same size and same type as src
return void

LogPolar() public static method

Remaps an image to log-polar space.
public static LogPolar ( InputArray src, OutputArray dst, Point2f center, double m, InterpolationFlags flags ) : void
src InputArray Source image
dst OutputArray Destination image
center Point2f The transformation center; where the output precision is maximal
m double Magnitude scale parameter.
flags InterpolationFlags A combination of interpolation methods, see cv::InterpolationFlags
return void

Magnitude() public static method

computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
public static Magnitude ( InputArray x, InputArray y, OutputArray magnitude ) : void
x InputArray
y InputArray
magnitude OutputArray
return void

Mahalanobis() public static method

public static Mahalanobis ( InputArray v1, InputArray v2, InputArray icovar ) : double
v1 InputArray
v2 InputArray
icovar InputArray
return double

Mahalonobis() public static method

computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
public static Mahalonobis ( InputArray v1, InputArray v2, InputArray icovar ) : double
v1 InputArray
v2 InputArray
icovar InputArray
return double

MatMulDeriv() public static method

computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
public static MatMulDeriv ( InputArray a, InputArray b, OutputArray dABdA, OutputArray dABdB ) : void
a InputArray First multiplied matrix.
b InputArray Second multiplied matrix.
dABdA OutputArray First output derivative matrix d(A*B)/dA of size A.rows*B.cols X A.rows*A.cols .
dABdB OutputArray Second output derivative matrix d(A*B)/dB of size A.rows*B.cols X B.rows*B.cols .
return void

MatchShapes() public static method

matches two contours using one of the available algorithms
public static MatchShapes ( IEnumerable contour1, IEnumerable contour2, ShapeMatchModes method, double parameter ) : double
contour1 IEnumerable
contour2 IEnumerable
method ShapeMatchModes
parameter double
return double

MatchShapes() public static method

matches two contours using one of the available algorithms
public static MatchShapes ( InputArray contour1, InputArray contour2, ShapeMatchModes method, double parameter ) : double
contour1 InputArray
contour2 InputArray
method ShapeMatchModes
parameter double
return double

MatchTemplate() public static method

Computes the proximity map for the raster template and the image where the template is searched for
public static MatchTemplate ( InputArray image, InputArray templ, OutputArray result, TemplateMatchModes method, InputArray mask = null ) : void
image InputArray Image where the search is running; should be 8-bit or 32-bit floating-point
templ InputArray Searched template; must be not greater than the source image and have the same data type
result OutputArray 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).
method TemplateMatchModes Specifies the comparison method
mask InputArray Mask of searched template. It must have the same datatype and size with templ. It is not set by default.
return void

Max() public static method

computes per-element maximum of two arrays (dst = max(src1, src2))
public static Max ( InputArray src1, InputArray src2, OutputArray dst ) : void
src1 InputArray
src2 InputArray
dst OutputArray
return void

Max() public static method

computes per-element maximum of two arrays (dst = max(src1, src2))
public static Max ( Mat src1, Mat src2, Mat dst ) : void
src1 Mat
src2 Mat
dst Mat
return void

Max() public static method

computes per-element maximum of array and scalar (dst = max(src1, src2))
public static Max ( Mat src1, double src2, Mat dst ) : void
src1 Mat
src2 double
dst Mat
return void

Mean() public static method

computes mean value of selected array elements
public static Mean ( InputArray src, InputArray mask = null ) : Scalar
src InputArray The source array; it should have 1 to 4 channels /// (so that the result can be stored in Scalar)
mask InputArray The optional operation mask
return Scalar

MeanShift() public static method

Finds an object on a back projection image.
public static MeanShift ( InputArray probImage, Rect &window, TermCriteria criteria ) : int
probImage InputArray Back projection of the object histogram.
window Rect Initial search window.
criteria TermCriteria Stop criteria for the iterative search algorithm.
return int

MeanStdDev() public static method

computes mean value and standard deviation of all or selected array elements
public static MeanStdDev ( InputArray src, OutputArray mean, OutputArray stddev, InputArray mask = null ) : void
src InputArray The source array; it should have 1 to 4 channels /// (so that the results can be stored in Scalar's)
mean OutputArray The output parameter: computed mean value
stddev OutputArray The output parameter: computed standard deviation
mask InputArray The optional operation mask
return void

MeanStdDev() public static method

computes mean value and standard deviation of all or selected array elements
public static MeanStdDev ( InputArray src, Scalar &mean, Scalar &stddev, InputArray mask = null ) : void
src InputArray The source array; it should have 1 to 4 channels /// (so that the results can be stored in Scalar's)
mean Scalar The output parameter: computed mean value
stddev Scalar The output parameter: computed standard deviation
mask InputArray The optional operation mask
return void

MedianBlur() public static method

Smoothes image using median filter
public static MedianBlur ( InputArray src, OutputArray dst, int ksize ) : void
src InputArray 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
dst OutputArray The destination array; will have the same size and the same type as src
ksize int The aperture linear size. It must be odd and more than 1, i.e. 3, 5, 7 ...
return void

Merge() public static method

makes multi-channel array out of several single-channel arrays
public static Merge ( Mat mv, Mat dst ) : void
mv Mat
dst Mat
return void

Min() public static method

computes per-element minimum of two arrays (dst = min(src1, src2))
public static Min ( InputArray src1, InputArray src2, OutputArray dst ) : void
src1 InputArray
src2 InputArray
dst OutputArray
return void

Min() public static method

computes per-element minimum of two arrays (dst = min(src1, src2))
public static Min ( Mat src1, Mat src2, Mat dst ) : void
src1 Mat
src2 Mat
dst Mat
return void

Min() public static method

computes per-element minimum of array and scalar (dst = min(src1, src2))
public static Min ( Mat src1, double src2, Mat dst ) : void
src1 Mat
src2 double
dst Mat
return void

MinAreaRect() public static method

Finds the minimum area rotated rectangle enclosing a 2D point set.
public static MinAreaRect ( IEnumerable points ) : RotatedRect
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return RotatedRect

MinAreaRect() public static method

Finds the minimum area rotated rectangle enclosing a 2D point set.
public static MinAreaRect ( IEnumerable points ) : RotatedRect
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return RotatedRect

MinAreaRect() public static method

Finds the minimum area rotated rectangle enclosing a 2D point set.
public static MinAreaRect ( InputArray points ) : RotatedRect
points InputArray The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
return RotatedRect

MinEnclosingCircle() public static method

Finds the minimum area circle enclosing a 2D point set.
public static MinEnclosingCircle ( IEnumerable points, Point2f &center, float &radius ) : void
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
center Point2f The output center of the circle
radius float The output radius of the circle
return void

MinEnclosingCircle() public static method

Finds the minimum area circle enclosing a 2D point set.
public static MinEnclosingCircle ( IEnumerable points, Point2f &center, float &radius ) : void
points IEnumerable The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
center Point2f The output center of the circle
radius float The output radius of the circle
return void

MinEnclosingCircle() public static method

Finds the minimum area circle enclosing a 2D point set.
public static MinEnclosingCircle ( InputArray points, Point2f &center, float &radius ) : void
points InputArray The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix.
center Point2f The output center of the circle
radius float The output radius of the circle
return void

MinMaxIdx() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxIdx ( InputArray src, double &minVal, double &maxVal ) : void
src InputArray The source single-channel array
minVal double Pointer to returned minimum value
maxVal double Pointer to returned maximum value
return void

MinMaxIdx() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxIdx ( InputArray src, double &minVal, double &maxVal, int &minIdx, int &maxIdx, InputArray mask = null ) : void
src InputArray The source single-channel array
minVal double Pointer to returned minimum value
maxVal double Pointer to returned maximum value
minIdx int
maxIdx int
mask InputArray
return void

MinMaxIdx() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxIdx ( InputArray src, int &minIdx, int &maxIdx ) : void
src InputArray The source single-channel array
minIdx int
maxIdx int
return void

MinMaxLoc() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxLoc ( InputArray src, Point &minLoc, Point &maxLoc ) : void
src InputArray The source single-channel array
minLoc Point Pointer to returned minimum location
maxLoc Point Pointer to returned maximum location
return void

MinMaxLoc() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxLoc ( InputArray src, double &minVal, double &maxVal ) : void
src InputArray The source single-channel array
minVal double Pointer to returned minimum value
maxVal double Pointer to returned maximum value
return void

MinMaxLoc() public static method

finds global minimum and maximum array elements and returns their values and their locations
public static MinMaxLoc ( InputArray src, double &minVal, double &maxVal, Point &minLoc, Point &maxLoc, InputArray mask = null ) : void
src InputArray The source single-channel array
minVal double Pointer to returned minimum value
maxVal double Pointer to returned maximum value
minLoc Point Pointer to returned minimum location
maxLoc Point Pointer to returned maximum location
mask InputArray The optional mask used to select a sub-array
return void

MixChannels() public static method

copies selected channels from the input arrays to the selected channels of the output arrays
public static MixChannels ( Mat src, Mat dst, int fromTo ) : void
src Mat
dst Mat
fromTo int
return void

Moments() public static method

Calculates all of the moments up to the third order of a polygon or rasterized shape.
public static Moments ( IEnumerable array, bool binaryImage = false ) : Moments
array IEnumerable Array of 2D points
binaryImage bool If it is true, then all the non-zero image pixels are treated as 1’s
return Moments

Moments() public static method

Calculates all of the moments up to the third order of a polygon or rasterized shape.
public static Moments ( IEnumerable array, bool binaryImage = false ) : Moments
array IEnumerable Array of 2D points
binaryImage bool If it is true, then all the non-zero image pixels are treated as 1’s
return Moments

Moments() public static method

Calculates all of the moments up to the third order of a polygon or rasterized shape.
public static Moments ( InputArray array, bool binaryImage = false ) : Moments
array InputArray A raster image (single-channel, 8-bit or floating-point /// 2D array) or an array ( 1xN or Nx1 ) of 2D points ( Point or Point2f )
binaryImage bool If it is true, then all the non-zero image pixels are treated as 1’s
return Moments

Moments() public static method

Calculates all of the moments up to the third order of a polygon or rasterized shape.
public static Moments ( byte array, bool binaryImage = false ) : Moments
array byte A raster image (8-bit) 2D array
binaryImage bool If it is true, then all the non-zero image pixels are treated as 1’s
return Moments

Moments() public static method

Calculates all of the moments up to the third order of a polygon or rasterized shape.
public static Moments ( float array, bool binaryImage = false ) : Moments
array float A raster image (floating-point) 2D array
binaryImage bool If it is true, then all the non-zero image pixels are treated as 1’s
return Moments

MorphologyDefaultBorderValue() public static method

Default borderValue for Dilate/Erode
public static MorphologyDefaultBorderValue ( ) : Scalar
return Scalar

MorphologyEx() public static method

Performs advanced morphological transformations
public static MorphologyEx ( InputArray src, OutputArray dst, MorphTypes op, InputArray element, Point anchor = null, int iterations = 1, BorderTypes borderType = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray Source image
dst OutputArray Destination image. It will have the same size and the same type as src
op MorphTypes Type of morphological operation
element InputArray Structuring element
anchor Point Position of the anchor within the element. The default value (-1, -1) means that the anchor is at the element center
iterations int Number of times erosion and dilation are applied. [By default this is 1]
borderType BorderTypes The pixel extrapolation method. [By default this is BorderType.Constant]
borderValue Scalar The border value in case of a constant border. The default value has a special meaning. [By default this is CvCpp.MorphologyDefaultBorderValue()]
return void

MoveWindow() public static method

Moves window to the specified position
public static MoveWindow ( string winName, int x, int y ) : void
winName string Window name
x int The new x-coordinate of the window
y int The new y-coordinate of the window
return void

MulSpectrums() public static method

computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
public static MulSpectrums ( InputArray a, InputArray b, OutputArray c, DftFlags flags, bool conjB = false ) : void
a InputArray
b InputArray
c OutputArray
flags DftFlags
conjB bool
return void

MulTransposed() public static method

multiplies matrix by its transposition from the left or from the right
public static MulTransposed ( InputArray src, OutputArray dst, bool aTa, InputArray delta = null, double scale = 1, int dtype = -1 ) : void
src InputArray The source matrix
dst OutputArray The destination square matrix
aTa bool Specifies the multiplication ordering; see the description below
delta InputArray 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
scale double The optional scale factor for the matrix product
dtype int 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
return void

Multiply() public static method

Calculates the per-element scaled product of two arrays
public static Multiply ( InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1 ) : void
src1 InputArray The first source array
src2 InputArray The second source array of the same size and the same type as src1
dst OutputArray The destination array; will have the same size and the same type as src1
scale double The optional scale factor. [By default this is 1]
dtype int
return void

NamedWindow() public static method

Creates a window.
public static NamedWindow ( string winname ) : void
winname string Name of the window in the window caption that may be used as a window identifier.
return void

NamedWindow() public static method

Creates a window.
public static NamedWindow ( string winname, WindowMode flags ) : void
winname string Name of the window in the window caption that may be used as a window identifier.
flags WindowMode /// 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. ///
return void

Norm() public static method

computes norm of selected part of the difference between two arrays
public static Norm ( InputArray src1, InputArray src2, NormTypes normType = NormTypes.L2, InputArray mask = null ) : double
src1 InputArray The first source array
src2 InputArray The second source array of the same size and the same type as src1
normType NormTypes Type of the norm
mask InputArray The optional operation mask
return double

Norm() public static method

Calculates absolute array norm, absolute difference norm, or relative difference norm.
public static Norm ( InputArray src1, NormTypes normType = NormTypes.L2, InputArray mask = null ) : double
src1 InputArray The first source array
normType NormTypes Type of the norm
mask InputArray The optional operation mask
return double

Normalize() public static method

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
public static Normalize ( InputArray src, InputOutputArray dst, double alpha = 1, double beta, NormTypes normType = NormTypes.L2, int dtype = -1, InputArray mask = null ) : void
src InputArray The source array
dst InputOutputArray The destination array; will have the same size as src
alpha double The norm value to normalize to or the lower range boundary /// in the case of range normalization
beta double The upper range boundary in the case of range normalization; /// not used for norm normalization
normType NormTypes The normalization type
dtype int 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)
mask InputArray The optional operation mask
return void

PCABackProject() public static method

public static PCABackProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void
data InputArray
mean InputArray
eigenvectors InputArray
result OutputArray
return void

PCACompute() public static method

PCA of the supplied dataset.
public static PCACompute ( InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents ) : void
data InputArray input samples stored as the matrix rows or as the matrix columns.
mean InputOutputArray optional mean value; if the matrix is empty (noArray()), the mean is computed from the data.
eigenvectors OutputArray
maxComponents int maximum number of components that PCA should /// retain; by default, all the components are retained.
return void

PCAComputeVar() public static method

public static PCAComputeVar ( InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance ) : void
data InputArray
mean InputOutputArray
eigenvectors OutputArray
retainedVariance double
return void

PCAProject() public static method

public static PCAProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void
data InputArray
mean InputArray
eigenvectors InputArray
result OutputArray
return void

PSNR() public static method

public static PSNR ( InputArray src1, InputArray src2 ) : double
src1 InputArray
src2 InputArray
return double

PatchNaNs() public static method

converts NaN's to the given number
public static PatchNaNs ( InputOutputArray a, double val ) : void
a InputOutputArray
val double
return void

PencilSketch() public static method

Pencil-like non-photorealistic line drawing
public static PencilSketch ( InputArray src, OutputArray dst1, OutputArray dst2, float sigmaS = 60, float sigmaR = 0.07f, float shadeFactor = 0.02f ) : void
src InputArray Input 8-bit 3-channel image.
dst1 OutputArray Output 8-bit 1-channel image.
dst2 OutputArray Output image with the same size and type as src.
sigmaS float Range between 0 to 200.
sigmaR float Range between 0 to 1.
shadeFactor float Range between 0 to 0.1.
return void

PerspectiveTransform() public static method

performs perspective transformation of each element of multi-channel input matrix
public static PerspectiveTransform ( IEnumerable src, Mat m ) : Point2d[]
src IEnumerable The source two-channel or three-channel floating-point array; /// each element is 2D/3D vector to be transformed
m Mat 3x3 or 4x4 transformation matrix
return Point2d[]

PerspectiveTransform() public static method

performs perspective transformation of each element of multi-channel input matrix
public static PerspectiveTransform ( IEnumerable src, Mat m ) : Point2f[]
src IEnumerable The source two-channel or three-channel floating-point array; /// each element is 2D/3D vector to be transformed
m Mat 3x3 or 4x4 transformation matrix
return Point2f[]

PerspectiveTransform() public static method

performs perspective transformation of each element of multi-channel input matrix
public static PerspectiveTransform ( IEnumerable src, Mat m ) : Point3d[]
src IEnumerable The source two-channel or three-channel floating-point array; /// each element is 2D/3D vector to be transformed
m Mat 3x3 or 4x4 transformation matrix
return Point3d[]

PerspectiveTransform() public static method

performs perspective transformation of each element of multi-channel input matrix
public static PerspectiveTransform ( IEnumerable src, Mat m ) : Point3f[]
src IEnumerable The source two-channel or three-channel floating-point array; /// each element is 2D/3D vector to be transformed
m Mat 3x3 or 4x4 transformation matrix
return Point3f[]

PerspectiveTransform() public static method

performs perspective transformation of each element of multi-channel input matrix
public static PerspectiveTransform ( InputArray src, OutputArray dst, InputArray m ) : void
src InputArray The source two-channel or three-channel floating-point array; /// each element is 2D/3D vector to be transformed
dst OutputArray The destination array; it will have the same size and same type as src
m InputArray 3x3 or 4x4 transformation matrix
return void

Phase() public static method

computes angle (angle(i)) of each (x(i), y(i)) vector
public static Phase ( InputArray x, InputArray y, OutputArray angle, bool angleInDegrees = false ) : void
x InputArray
y InputArray
angle OutputArray
angleInDegrees bool
return void

PhaseCorrelate() public static method

public static PhaseCorrelate ( InputArray src1, InputArray src2, InputArray window = null ) : Point2d
src1 InputArray
src2 InputArray
window InputArray
return Point2d

PhaseCorrelateRes() public static method

public static PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window ) : Point2d
src1 InputArray
src2 InputArray
window InputArray
return Point2d

PhaseCorrelateRes() public static method

public static PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window, double &response ) : Point2d
src1 InputArray
src2 InputArray
window InputArray
response double
return Point2d

PointPolygonTest() public static method

Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary.
public static PointPolygonTest ( IEnumerable contour, Point2f pt, bool measureDist ) : double
contour IEnumerable Input contour.
pt Point2f Point tested against the contour.
measureDist bool 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.
return double

PointPolygonTest() public static method

Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
public static PointPolygonTest ( IEnumerable contour, Point2f pt, bool measureDist ) : double
contour IEnumerable
pt Point2f
measureDist bool
return double

PointPolygonTest() public static method

Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
public static PointPolygonTest ( InputArray contour, Point2f pt, bool measureDist ) : double
contour InputArray
pt Point2f
measureDist bool
return double

PolarToCart() public static method

converts polar coordinates to Cartesian
public static PolarToCart ( InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees = false ) : void
magnitude InputArray
angle InputArray
x OutputArray
y OutputArray
angleInDegrees bool
return void

Polylines() public static method

draws one or more polygonal curves
public static Polylines ( InputOutputArray img, InputArray pts, bool isClosed, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img InputOutputArray
pts InputArray
isClosed bool
color Scalar
thickness int
lineType LineTypes
shift int
return void

Polylines() public static method

draws one or more polygonal curves
public static Polylines ( Mat img, IEnumerable pts, bool isClosed, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img Mat
pts IEnumerable
isClosed bool
color Scalar
thickness int
lineType LineTypes
shift int
return void

Pow() public static method

raises the input matrix elements to the specified power (b = a**power)
public static Pow ( InputArray src, double power, OutputArray dst ) : void
src InputArray The source array
power double The exponent of power
dst OutputArray The destination array; will have the same size and the same type as src
return void

PreCornerDetect() public static method

computes another complex cornerness criteria at each pixel
public static PreCornerDetect ( InputArray src, OutputArray dst, int ksize, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray
dst OutputArray
ksize int
borderType BorderTypes
return void

ProjectPoints() public static method

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
public static ProjectPoints ( IEnumerable objectPoints, double rvec, double tvec, double cameraMatrix, double distCoeffs, Point2f &imagePoints, double &jacobian, double aspectRatio ) : void
objectPoints IEnumerable Array of object points, 3xN/Nx3 1-channel or /// 1xN/Nx1 3-channel, where N is the number of points in the view.
rvec double Rotation vector (3x1).
tvec double Translation vector (3x1).
cameraMatrix double Camera matrix (3x3)
distCoeffs double 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.
imagePoints Point2f Output array of image points, 2xN/Nx2 1-channel /// or 1xN/Nx1 2-channel
jacobian double 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.
aspectRatio double 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.
return void

ProjectPoints() public static method

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
public static ProjectPoints ( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian = null, double aspectRatio ) : void
objectPoints InputArray Array of object points, 3xN/Nx3 1-channel or /// 1xN/Nx1 3-channel, where N is the number of points in the view.
rvec InputArray Rotation vector (3x1).
tvec InputArray Translation vector (3x1).
cameraMatrix InputArray Camera matrix (3x3)
distCoeffs InputArray 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.
imagePoints OutputArray Output array of image points, 2xN/Nx2 1-channel /// or 1xN/Nx1 2-channel
jacobian OutputArray 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.
aspectRatio double 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.
return void

PutText() public static method

renders text string in the image
public static PutText ( InputOutputArray img, string text, Point org, HersheyFonts fontFace, double fontScale, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, bool bottomLeftOrigin = false ) : void
img InputOutputArray
text string
org Point
fontFace HersheyFonts
fontScale double
color Scalar
thickness int
lineType LineTypes
bottomLeftOrigin bool
return void

PyrDown() public static method

Blurs an image and downsamples it.
public static PyrDown ( InputArray src, OutputArray dst, Size dstSize = null, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray input image.
dst OutputArray output image; it has the specified size and the same type as src.
dstSize Size size of the output image; by default, it is computed as Size((src.cols+1)/2
borderType BorderTypes
return void

PyrMeanShiftFiltering() public static method

Performs initial step of meanshift segmentation of an image.
public static PyrMeanShiftFiltering ( InputArray src, OutputArray dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = null ) : void
src InputArray The source 8-bit, 3-channel image.
dst OutputArray The destination image of the same format and the same size as the source.
sp double The spatial window radius.
sr double The color window radius.
maxLevel int Maximum level of the pyramid for the segmentation.
termcrit TermCriteria Termination criteria: when to stop meanshift iterations.
return void

PyrUp() public static method

Upsamples an image and then blurs it.
public static PyrUp ( InputArray src, OutputArray dst, Size dstSize = null, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray input image.
dst OutputArray output image. It has the specified size and the same type as src.
dstSize Size size of the output image; by default, it is computed as Size(src.cols*2, (src.rows*2)
borderType BorderTypes
return void

RQDecomp3x3() public static method

Computes RQ decomposition of 3x3 matrix
public static RQDecomp3x3 ( InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray qx = null, OutputArray qy = null, OutputArray qz = null ) : Vec3d
src InputArray 3x3 input matrix.
mtxR OutputArray Output 3x3 upper-triangular matrix.
mtxQ OutputArray Output 3x3 orthogonal matrix.
qx OutputArray Optional output 3x3 rotation matrix around x-axis.
qy OutputArray Optional output 3x3 rotation matrix around y-axis.
qz OutputArray Optional output 3x3 rotation matrix around z-axis.
return Vec3d

RQDecomp3x3() public static method

Computes RQ decomposition of 3x3 matrix
public static RQDecomp3x3 ( double src, double &mtxR, double &mtxQ ) : Vec3d
src double 3x3 input matrix.
mtxR double Output 3x3 upper-triangular matrix.
mtxQ double Output 3x3 orthogonal matrix.
return Vec3d

RQDecomp3x3() public static method

Computes RQ decomposition of 3x3 matrix
public static RQDecomp3x3 ( double src, double &mtxR, double &mtxQ, double &qx, double &qy, double &qz ) : Vec3d
src double 3x3 input matrix.
mtxR double Output 3x3 upper-triangular matrix.
mtxQ double Output 3x3 orthogonal matrix.
qx double Optional output 3x3 rotation matrix around x-axis.
qy double Optional output 3x3 rotation matrix around y-axis.
qz double Optional output 3x3 rotation matrix around z-axis.
return Vec3d

RandShuffle() public static method

shuffles the input array elements
public static RandShuffle ( InputOutputArray dst, double iterFactor, RNG rng = null ) : void
dst InputOutputArray The input/output numerical 1D array
iterFactor double The scale factor that determines the number of random swap operations.
rng RNG The optional random number generator used for shuffling. /// If it is null, theRng() is used instead.
return void

Randn() public static method

fills array with normally-distributed random numbers with the specified mean and the standard deviation
public static Randn ( InputOutputArray dst, InputArray mean, InputArray stddev ) : void
dst InputOutputArray The output array of random numbers. /// The array must be pre-allocated and have 1 to 4 channels
mean InputArray The mean value (expectation) of the generated random numbers
stddev InputArray The standard deviation of the generated random numbers
return void

Randn() public static method

fills array with normally-distributed random numbers with the specified mean and the standard deviation
public static Randn ( InputOutputArray dst, Scalar mean, Scalar stddev ) : void
dst InputOutputArray The output array of random numbers. /// The array must be pre-allocated and have 1 to 4 channels
mean Scalar The mean value (expectation) of the generated random numbers
stddev Scalar The standard deviation of the generated random numbers
return void

Randu() public static method

fills array with uniformly-distributed random numbers from the range [low, high)
public static Randu ( InputOutputArray dst, InputArray low, InputArray high ) : void
dst InputOutputArray The output array of random numbers. /// The array must be pre-allocated and have 1 to 4 channels
low InputArray The inclusive lower boundary of the generated random numbers
high InputArray The exclusive upper boundary of the generated random numbers
return void

Randu() public static method

fills array with uniformly-distributed random numbers from the range [low, high)
public static Randu ( InputOutputArray dst, Scalar low, Scalar high ) : void
dst InputOutputArray The output array of random numbers. /// The array must be pre-allocated and have 1 to 4 channels
low Scalar The inclusive lower boundary of the generated random numbers
high Scalar The exclusive upper boundary of the generated random numbers
return void

ReadDMatches() public static method

public static ReadDMatches ( FileNode node ) : DMatch[]
node FileNode
return DMatch[]

ReadDouble() public static method

public static ReadDouble ( FileNode node, double defaultValue = default(double) ) : double
node FileNode
defaultValue double
return double

ReadFloat() public static method

public static ReadFloat ( FileNode node, float defaultValue = default(float) ) : float
node FileNode
defaultValue float
return float

ReadInt() public static method

public static ReadInt ( FileNode node, int defaultValue = default(int) ) : int
node FileNode
defaultValue int
return int

ReadKeyPoints() public static method

public static ReadKeyPoints ( FileNode node ) : KeyPoint[]
node FileNode
return KeyPoint[]

ReadMat() public static method

public static ReadMat ( FileNode node, Mat defaultMat = null ) : Mat
node FileNode
defaultMat Mat
return Mat

ReadSparseMat() public static method

public static ReadSparseMat ( FileNode node, SparseMat defaultMat = null ) : SparseMat
node FileNode
defaultMat SparseMat
return SparseMat

ReadString() public static method

public static ReadString ( FileNode node, string defaultValue = default(string) ) : string
node FileNode
defaultValue string
return string

Rectangle() public static method

Draws simple, thick or filled rectangle
public static Rectangle ( InputOutputArray img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img InputOutputArray Image.
pt1 Point One of the rectangle vertices.
pt2 Point Opposite rectangle vertex.
color Scalar Line color (RGB) or brightness (grayscale image).
thickness int Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1]
lineType LineTypes Type of the line, see cvLine description. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

Rectangle() public static method

Draws simple, thick or filled rectangle
public static Rectangle ( InputOutputArray img, Rect rect, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img InputOutputArray Image.
rect Rect Rectangle.
color Scalar Line color (RGB) or brightness (grayscale image).
thickness int Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1]
lineType LineTypes Type of the line, see cvLine description. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

Rectangle() public static method

Draws simple, thick or filled rectangle
public static Rectangle ( Mat img, Point pt1, Point pt2, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img Mat Image.
pt1 Point One of the rectangle vertices.
pt2 Point Opposite rectangle vertex.
color Scalar Line color (RGB) or brightness (grayscale image).
thickness int Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1]
lineType LineTypes Type of the line, see cvLine description. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

Rectangle() public static method

Draws simple, thick or filled rectangle
public static Rectangle ( Mat img, Rect rect, Scalar color, int thickness = 1, LineTypes lineType = LineTypes.Link8, int shift ) : void
img Mat Image.
rect Rect Rectangle.
color Scalar Line color (RGB) or brightness (grayscale image).
thickness int Thickness of lines that make up the rectangle. Negative values make the function to draw a filled rectangle. [By default this is 1]
lineType LineTypes Type of the line, see cvLine description. [By default this is LineType.Link8]
shift int Number of fractional bits in the point coordinates. [By default this is 0]
return void

Rectify3Collinear() public static method

computes the rectification transformations for 3-head camera, where all the heads are on the same line.
public static Rectify3Collinear ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, IEnumerable imgpt1, IEnumerable imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, Rect &roi1, Rect &roi2, StereoRectificationFlags flags ) : float
cameraMatrix1 InputArray
distCoeffs1 InputArray
cameraMatrix2 InputArray
distCoeffs2 InputArray
cameraMatrix3 InputArray
distCoeffs3 InputArray
imgpt1 IEnumerable
imgpt3 IEnumerable
imageSize Size
R12 InputArray
T12 InputArray
R13 InputArray
T13 InputArray
R1 OutputArray
R2 OutputArray
R3 OutputArray
P1 OutputArray
P2 OutputArray
P3 OutputArray
Q OutputArray
alpha double
newImgSize Size
roi1 Rect
roi2 Rect
flags StereoRectificationFlags
return float

Reduce() public static method

transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
public static Reduce ( InputArray src, OutputArray dst, ReduceDimension dim, ReduceTypes rtype, int dtype ) : void
src InputArray The source 2D matrix
dst OutputArray The destination vector. /// Its size and type is defined by dim and dtype parameters
dim ReduceDimension 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
rtype ReduceTypes
dtype int 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())
return void

Remap() public static method

Applies a generic geometrical transformation to an image.
public static Remap ( InputArray src, OutputArray dst, InputArray map1, InputArray map2, InterpolationFlags interpolation = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray Source image.
dst OutputArray Destination image. It has the same size as map1 and the same type as src
map1 InputArray The first map of either (x,y) points or just x values having the type CV_16SC2, CV_32FC1, or CV_32FC2.
map2 InputArray 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 InterpolationFlags Interpolation method. The method INTER_AREA is not supported by this function.
borderMode BorderTypes 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.
borderValue Scalar Value used in case of a constant border. By default, it is 0.
return void

Repeat() public static method

replicates the input matrix the specified number of times in the horizontal and/or vertical direction
public static Repeat ( Mat src, int ny, int nx ) : Mat
src Mat The source array to replicate
ny int How many times the src is repeated along the vertical axis
nx int How many times the src is repeated along the horizontal axis
return Mat

Repeat() public static method

replicates the input matrix the specified number of times in the horizontal and/or vertical direction
public static Repeat ( InputArray src, int ny, int nx, OutputArray dst ) : void
src InputArray The source array to replicate
ny int How many times the src is repeated along the vertical axis
nx int How many times the src is repeated along the horizontal axis
dst OutputArray The destination array; will have the same type as src
return void

ReprojectImageTo3D() public static method

reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
public static ReprojectImageTo3D ( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues = false, int ddepth = -1 ) : void
disparity InputArray Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image.
_3dImage OutputArray 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.
Q InputArray 4 x 4 perspective transformation matrix that can be obtained with stereoRectify().
handleMissingValues bool 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).
ddepth int 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.
return void

Resize() public static method

Resizes an image.
public static Resize ( InputArray src, OutputArray dst, Size dsize, double fx, double fy, InterpolationFlags interpolation = InterpolationFlags.Linear ) : void
src InputArray input image.
dst OutputArray 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.
dsize Size 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.
fx double scale factor along the horizontal axis; when it equals 0, /// it is computed as: (double)dsize.width/src.cols
fy double scale factor along the vertical axis; when it equals 0, /// it is computed as: (double)dsize.height/src.rows
interpolation InterpolationFlags interpolation method
return void

ResizeWindow() public static method

Resizes window to the specified size
public static ResizeWindow ( string winName, int width, int height ) : void
winName string Window name
width int The new window width
height int The new window height
return void

Rodrigues() public static method

converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
public static Rodrigues ( InputArray src, OutputArray dst, OutputArray jacobian = null ) : void
src InputArray Input rotation vector (3x1 or 1x3) or rotation matrix (3x3).
dst OutputArray Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively.
jacobian OutputArray 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.
return void

Rodrigues() public static method

converts rotation vector to rotation matrix using Rodrigues transformation
public static Rodrigues ( double vector, double &matrix ) : void
vector double Input rotation vector (3x1).
matrix double Output rotation matrix (3x3).
return void

Rodrigues() public static method

converts rotation vector to rotation matrix using Rodrigues transformation
public static Rodrigues ( double vector, double &matrix, double &jacobian ) : void
vector double Input rotation vector (3x1).
matrix double Output rotation matrix (3x3).
jacobian double Optional output Jacobian matrix, 3x9, which is a matrix of partial derivatives of the output array components with respect to the input array components.
return void

RotatedRectangleIntersection() public static method

Finds out if there is any intersection between two rotated rectangles. If there is then the vertices of the interesecting region are returned as well. Below are some examples of intersection configurations. The hatched pattern indicates the intersecting region and the red vertices are returned by the function.
public static RotatedRectangleIntersection ( RotatedRect rect1, RotatedRect rect2, OutputArray intersectingRegion ) : RectanglesIntersectTypes
rect1 RotatedRect First rectangle
rect2 RotatedRect Second rectangle
intersectingRegion OutputArray /// The output array of the verticies of the intersecting region. /// It returns at most 8 vertices. /// Stored as std::vector<cv::Point2f> or cv::Mat as Mx1 of type CV_32FC2.
return RectanglesIntersectTypes

RotatedRectangleIntersection() public static method

Finds out if there is any intersection between two rotated rectangles. If there is then the vertices of the interesecting region are returned as well. Below are some examples of intersection configurations. The hatched pattern indicates the intersecting region and the red vertices are returned by the function.
public static RotatedRectangleIntersection ( RotatedRect rect1, RotatedRect rect2, Point2f &intersectingRegion ) : RectanglesIntersectTypes
rect1 RotatedRect First rectangle
rect2 RotatedRect Second rectangle
intersectingRegion Point2f /// The output array of the verticies of the intersecting region. /// It returns at most 8 vertices.
return RectanglesIntersectTypes

SVBackSubst() public static method

performs back substitution for the previously computed SVD
public static SVBackSubst ( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ) : void
w InputArray
u InputArray
vt InputArray
rhs InputArray
dst OutputArray
return void

SVDecomp() public static method

computes SVD of src
public static SVDecomp ( InputArray src, OutputArray w, OutputArray u, OutputArray vt, SVD flags = SVD.Flags.None ) : void
src InputArray
w OutputArray
u OutputArray
vt OutputArray
flags SVD
return void

ScaleAdd() public static method

adds scaled array to another one (dst = alpha*src1 + src2)
public static ScaleAdd ( InputArray src1, double alpha, InputArray src2, OutputArray dst ) : void
src1 InputArray
alpha double
src2 InputArray
dst OutputArray
return void

Scharr() public static method

Calculates the first x- or y- image derivative using Scharr operator
public static Scharr ( InputArray src, OutputArray dst, MatType ddepth, int xorder, int yorder, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same size and the same number of channels as src
ddepth MatType The destination image depth
xorder int Order of the derivative x
yorder int Order of the derivative y
scale double The optional scale factor for the computed derivative values (by default, no scaling is applie
delta double The optional delta value, added to the results prior to storing them in dst
borderType BorderTypes The pixel extrapolation method
return void

SeamlessClone() public static method

Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content @cite PM03 .
public static SeamlessClone ( InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, SeamlessCloneMethods flags ) : void
src InputArray Input 8-bit 3-channel image.
dst InputArray Input 8-bit 3-channel image.
mask InputArray Input 8-bit 1 or 3-channel image.
p Point Point in dst image where object is placed.
blend OutputArray Output image with the same size and type as dst.
flags SeamlessCloneMethods Cloning method
return void

SegmentMotion() public static method

Splits a motion history image into a few parts corresponding to separate independent motions (for example, left hand, right hand).
public static SegmentMotion ( InputArray mhi, OutputArray segmask, Rect &boundingRects, double timestamp, double segThresh ) : void
mhi InputArray Motion history image.
segmask OutputArray Image where the found mask should be stored, single-channel, 32-bit floating-point.
boundingRects Rect Vector containing ROIs of motion connected components.
timestamp double Current time in milliseconds or other units.
segThresh double Segmentation threshold that is recommended to be equal to the interval between motion history “steps” or greater.
return void

SepFilter2D() public static method

Applies separable linear filter to an image
public static SepFilter2D ( InputArray src, OutputArray dst, MatType ddepth, InputArray kernelX, InputArray kernelY, Point anchor = null, double delta, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same size and the same number of channels as src
ddepth MatType The destination image depth
kernelX InputArray The coefficients for filtering each row
kernelY InputArray The coefficients for filtering each column
anchor Point The anchor position within the kernel; The default value (-1, 1) means that the anchor is at the kernel center
delta double The value added to the filtered results before storing them
borderType BorderTypes The pixel extrapolation method
return void

SetIdentity() public static method

initializes scaled identity matrix
public static SetIdentity ( InputOutputArray mtx, Scalar s = null ) : void
mtx InputOutputArray The matrix to initialize (not necessarily square)
s Scalar The value to assign to the diagonal elements
return void

SetMouseCallback() public static method

Sets the callback function for mouse events occuting within the specified window.
public static SetMouseCallback ( string windowName, CvMouseCallback onMouse ) : void
windowName string Name of the window.
onMouse CvMouseCallback Reference to the function to be called every time mouse event occurs in the specified window.
return void

SetNumThreads() public static method

public static SetNumThreads ( int nthreads ) : void
nthreads int
return void

SetUseOptimized() public static method

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.
public static SetUseOptimized ( bool onoff ) : void
onoff bool
return void

SetWindowProperty() public static method

Changes parameters of a window dynamically.
public static SetWindowProperty ( string winName, WindowProperty propId, double propValue ) : void
winName string Name of the window.
propId WindowProperty Window property to retrieve.
propValue double New value of the window property.
return void

SetWindowTitle() public static method

Updates window title
public static SetWindowTitle ( string winname, string title ) : void
winname string
title string
return void

Sobel() public static method

Calculates the first, second, third or mixed image derivatives using an extended Sobel operator
public static Sobel ( InputArray src, OutputArray dst, MatType ddepth, int xorder, int yorder, int ksize = 3, double scale = 1, double delta, BorderTypes borderType = BorderTypes.Default ) : void
src InputArray The source image
dst OutputArray The destination image; will have the same size and the same number of channels as src
ddepth MatType The destination image depth
xorder int Order of the derivative x
yorder int Order of the derivative y
ksize int Size of the extended Sobel kernel, must be 1, 3, 5 or 7
scale double The optional scale factor for the computed derivative values (by default, no scaling is applied
delta double The optional delta value, added to the results prior to storing them in dst
borderType BorderTypes The pixel extrapolation method
return void

Solve() public static method

solves linear system or a least-square problem
public static Solve ( InputArray src1, InputArray src2, OutputArray dst, DecompTypes flags = DecompTypes.LU ) : bool
src1 InputArray
src2 InputArray
dst OutputArray
flags DecompTypes
return bool

SolveCubic() public static method

finds real roots of a cubic polynomial
public static SolveCubic ( InputArray coeffs, OutputArray roots ) : int
coeffs InputArray The equation coefficients, an array of 3 or 4 elements
roots OutputArray The destination array of real roots which will have 1 or 3 elements
return int

SolvePnP() public static method

Finds an object pose from 3D-2D point correspondences.
public static SolvePnP ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec, bool useExtrinsicGuess = false, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
cameraMatrix double Input camera matrix
distCoeffs IEnumerable 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.
rvec double Output rotation vector that, together with tvec , brings points from the model coordinate system to the /// camera coordinate system.
tvec double Output translation vector.
useExtrinsicGuess bool 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.
flags SolvePnPFlags Method for solving a PnP problem:
return void

SolvePnP() public static method

Finds an object pose from 3D-2D point correspondences.
public static SolvePnP ( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess = false, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void
objectPoints InputArray 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.
imagePoints InputArray 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.
cameraMatrix InputArray Input camera matrix
distCoeffs InputArray 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.
rvec OutputArray Output rotation vector that, together with tvec , brings points from the model coordinate system to the /// camera coordinate system.
tvec OutputArray Output translation vector.
useExtrinsicGuess bool 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.
flags SolvePnPFlags Method for solving a PnP problem:
return void

SolvePnPRansac() public static method

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
public static SolvePnPRansac ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec ) : void
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
cameraMatrix double Input 3x3 camera matrix
distCoeffs IEnumerable 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.
rvec double Output rotation vector that, together with tvec , brings points from the model coordinate system /// to the camera coordinate system.
tvec double Output translation vector.
return void

SolvePnPRansac() public static method

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
public static SolvePnPRansac ( IEnumerable objectPoints, IEnumerable imagePoints, double cameraMatrix, IEnumerable distCoeffs, double &rvec, double &tvec, int &inliers, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0f, double confidence = 0.99, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void
objectPoints IEnumerable 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.
imagePoints IEnumerable 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.
cameraMatrix double Input 3x3 camera matrix
distCoeffs IEnumerable 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.
rvec double Output rotation vector that, together with tvec , brings points from the model coordinate system /// to the camera coordinate system.
tvec double Output translation vector.
inliers int Output vector that contains indices of inliers in objectPoints and imagePoints .
useExtrinsicGuess bool 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.
iterationsCount int Number of iterations.
reprojectionError float 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.
confidence double The probability that the algorithm produces a useful result.
flags SolvePnPFlags Method for solving a PnP problem
return void

SolvePnPRansac() public static method

computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
public static SolvePnPRansac ( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0f, double confidence = 0.99, OutputArray inliers = null, SolvePnPFlags flags = SolvePnPFlags.Iterative ) : void
objectPoints InputArray 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.
imagePoints InputArray 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.
cameraMatrix InputArray Input 3x3 camera matrix
distCoeffs InputArray 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.
rvec OutputArray Output rotation vector that, together with tvec , brings points from the model coordinate system /// to the camera coordinate system.
tvec OutputArray Output translation vector.
useExtrinsicGuess bool 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.
iterationsCount int Number of iterations.
reprojectionError float 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.
confidence double The probability that the algorithm produces a useful result.
inliers OutputArray Output vector that contains indices of inliers in objectPoints and imagePoints .
flags SolvePnPFlags Method for solving a PnP problem
return void

SolvePoly() public static method

finds real and complex roots of a polynomial
public static SolvePoly ( InputArray coeffs, OutputArray roots, int maxIters = 300 ) : double
coeffs InputArray The array of polynomial coefficients
roots OutputArray The destination (complex) array of roots
maxIters int The maximum number of iterations the algorithm does
return double

Sort() public static method

sorts independently each matrix row or each matrix column
public static Sort ( InputArray src, OutputArray dst, SortFlags flags ) : void
src InputArray The source single-channel array
dst OutputArray The destination array of the same size and the same type as src
flags SortFlags The operation flags, a combination of the SortFlag values
return void

SortIdx() public static method

sorts independently each matrix row or each matrix column
public static SortIdx ( InputArray src, OutputArray dst, SortFlags flags ) : void
src InputArray The source single-channel array
dst OutputArray The destination integer array of the same size as src
flags SortFlags The operation flags, a combination of SortFlag values
return void

Split() public static method

Copies each plane of a multi-channel array to a dedicated array
public static Split ( Mat src ) : Mat[]
src Mat The source multi-channel array
return Mat[]

Split() public static method

Copies each plane of a multi-channel array to a dedicated array
public static Split ( Mat src, Mat &mv ) : void
src Mat The source multi-channel array
mv Mat The destination array or vector of arrays; /// The number of arrays must match mtx.channels() . /// The arrays themselves will be reallocated if needed
return void

Sqrt() public static method

computes square root of each matrix element (dst = src**0.5)
public static Sqrt ( InputArray src, OutputArray dst ) : void
src InputArray The source floating-point array
dst OutputArray The destination array; will have the same size and the same type as src
return void

StartWindowThread() public static method

public static StartWindowThread ( ) : int
return int

StereoCalibrate() public static method

finds intrinsic and extrinsic parameters of a stereo camera
public static StereoCalibrate ( IEnumerable objectPoints, IEnumerable imagePoints1, IEnumerable imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, CalibrationFlags flags = CalibrationFlags.FixIntrinsic, TermCriteria criteria = null ) : double
objectPoints IEnumerable Vector of vectors of the calibration pattern points.
imagePoints1 IEnumerable Vector of vectors of the projections of the calibration pattern points, observed by the first camera.
imagePoints2 IEnumerable Vector of vectors of the projections of the calibration pattern points, observed by the second camera.
cameraMatrix1 InputOutputArray Input/output first camera matrix
distCoeffs1 InputOutputArray 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.
cameraMatrix2 InputOutputArray Input/output second camera matrix. The parameter is similar to cameraMatrix1 .
distCoeffs2 InputOutputArray Input/output lens distortion coefficients for the second camera. The parameter is similar to distCoeffs1 .
imageSize Size Size of the image used only to initialize intrinsic camera matrix.
R OutputArray Output rotation matrix between the 1st and the 2nd camera coordinate systems.
T OutputArray Output translation vector between the coordinate systems of the cameras.
E OutputArray Output essential matrix.
F OutputArray Output fundamental matrix.
flags CalibrationFlags Different flags that may be zero or a combination of the CalibrationFlag values
criteria TermCriteria Termination criteria for the iterative optimization algorithm.
return double

StereoCalibrate() public static method

finds intrinsic and extrinsic parameters of a stereo camera
public static StereoCalibrate ( IEnumerable objectPoints, IEnumerable imagePoints1, IEnumerable imagePoints2, double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, CalibrationFlags flags = CalibrationFlags.FixIntrinsic, TermCriteria criteria = null ) : double
objectPoints IEnumerable Vector of vectors of the calibration pattern points.
imagePoints1 IEnumerable Vector of vectors of the projections of the calibration pattern points, observed by the first camera.
imagePoints2 IEnumerable Vector of vectors of the projections of the calibration pattern points, observed by the second camera.
cameraMatrix1 double Input/output first camera matrix
distCoeffs1 double 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.
cameraMatrix2 double Input/output second camera matrix. The parameter is similar to cameraMatrix1 .
distCoeffs2 double Input/output lens distortion coefficients for the second camera. The parameter is similar to distCoeffs1 .
imageSize Size Size of the image used only to initialize intrinsic camera matrix.
R OutputArray Output rotation matrix between the 1st and the 2nd camera coordinate systems.
T OutputArray Output translation vector between the coordinate systems of the cameras.
E OutputArray Output essential matrix.
F OutputArray Output fundamental matrix.
flags CalibrationFlags Different flags that may be zero or a combination of the CalibrationFlag values
criteria TermCriteria Termination criteria for the iterative optimization algorithm.
return double

StereoRectify() public static method

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
public static StereoRectify ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, StereoRectificationFlags flags = StereoRectificationFlags.ZeroDisparity, double alpha = -1, Size newImageSize = null ) : void
cameraMatrix1 InputArray First camera matrix.
distCoeffs1 InputArray First camera distortion parameters.
cameraMatrix2 InputArray Second camera matrix.
distCoeffs2 InputArray Second camera distortion parameters.
imageSize Size Size of the image used for stereo calibration.
R InputArray Rotation matrix between the coordinate systems of the first and the second cameras.
T InputArray Translation vector between coordinate systems of the cameras.
R1 OutputArray Output 3x3 rectification transform (rotation matrix) for the first camera.
R2 OutputArray Output 3x3 rectification transform (rotation matrix) for the second camera.
P1 OutputArray Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera.
P2 OutputArray Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera.
Q OutputArray Output 4x4 disparity-to-depth mapping matrix (see reprojectImageTo3D() ).
flags StereoRectificationFlags 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.
alpha double 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.
newImageSize Size 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.
return void

StereoRectify() public static method

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
public static StereoRectify ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, StereoRectificationFlags flags, double alpha, Size newImageSize, Rect &validPixROI1, Rect &validPixROI2 ) : void
cameraMatrix1 InputArray First camera matrix.
distCoeffs1 InputArray First camera distortion parameters.
cameraMatrix2 InputArray Second camera matrix.
distCoeffs2 InputArray Second camera distortion parameters.
imageSize Size Size of the image used for stereo calibration.
R InputArray Rotation matrix between the coordinate systems of the first and the second cameras.
T InputArray Translation vector between coordinate systems of the cameras.
R1 OutputArray Output 3x3 rectification transform (rotation matrix) for the first camera.
R2 OutputArray Output 3x3 rectification transform (rotation matrix) for the second camera.
P1 OutputArray Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera.
P2 OutputArray Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera.
Q OutputArray Output 4x4 disparity-to-depth mapping matrix (see reprojectImageTo3D() ).
flags StereoRectificationFlags 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.
alpha double 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.
newImageSize Size 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.
validPixROI1 Rect Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. /// Otherwise, they are likely to be smaller.
validPixROI2 Rect Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. /// Otherwise, they are likely to be smaller.
return void

StereoRectify() public static method

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
public static StereoRectify ( double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, double R, double T, double &R1, double &R2, double &P1, double &P2, double &Q, StereoRectificationFlags flags = StereoRectificationFlags.ZeroDisparity, double alpha = -1, Size newImageSize = null ) : void
cameraMatrix1 double First camera matrix.
distCoeffs1 double First camera distortion parameters.
cameraMatrix2 double Second camera matrix.
distCoeffs2 double Second camera distortion parameters.
imageSize Size Size of the image used for stereo calibration.
R double Rotation matrix between the coordinate systems of the first and the second cameras.
T double Translation vector between coordinate systems of the cameras.
R1 double Output 3x3 rectification transform (rotation matrix) for the first camera.
R2 double Output 3x3 rectification transform (rotation matrix) for the second camera.
P1 double Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera.
P2 double Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera.
Q double Output 4x4 disparity-to-depth mapping matrix (see reprojectImageTo3D() ).
flags StereoRectificationFlags 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.
alpha double 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.
newImageSize Size 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.
return void

StereoRectify() public static method

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
public static StereoRectify ( double cameraMatrix1, double distCoeffs1, double cameraMatrix2, double distCoeffs2, Size imageSize, double R, double T, double &R1, double &R2, double &P1, double &P2, double &Q, StereoRectificationFlags flags, double alpha, Size newImageSize, Rect &validPixROI1, Rect &validPixROI2 ) : void
cameraMatrix1 double First camera matrix.
distCoeffs1 double First camera distortion parameters.
cameraMatrix2 double Second camera matrix.
distCoeffs2 double Second camera distortion parameters.
imageSize Size Size of the image used for stereo calibration.
R double Rotation matrix between the coordinate systems of the first and the second cameras.
T double Translation vector between coordinate systems of the cameras.
R1 double Output 3x3 rectification transform (rotation matrix) for the first camera.
R2 double Output 3x3 rectification transform (rotation matrix) for the second camera.
P1 double Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera.
P2 double Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera.
Q double Output 4x4 disparity-to-depth mapping matrix (see reprojectImageTo3D() ).
flags StereoRectificationFlags 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.
alpha double 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.
newImageSize Size 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.
validPixROI1 Rect Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. /// Otherwise, they are likely to be smaller.
validPixROI2 Rect Optional output rectangles inside the rectified images where all the pixels are valid. If alpha=0 , the ROIs cover the whole images. /// Otherwise, they are likely to be smaller.
return void

StereoRectifyUncalibrated() public static method

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
public static StereoRectifyUncalibrated ( IEnumerable points1, IEnumerable points2, double F, Size imgSize, double &H1, double &H2, double threshold = 5 ) : bool
points1 IEnumerable Array of feature points in the first image.
points2 IEnumerable The corresponding points in the second image. /// The same formats as in findFundamentalMat() are supported.
F double Input fundamental matrix. It can be computed from the same set /// of point pairs using findFundamentalMat() .
imgSize Size Size of the image.
H1 double Output rectification homography matrix for the first image.
H2 double Output rectification homography matrix for the second image.
threshold double 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.
return bool

StereoRectifyUncalibrated() public static method

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
public static StereoRectifyUncalibrated ( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold = 5 ) : bool
points1 InputArray Array of feature points in the first image.
points2 InputArray The corresponding points in the second image. /// The same formats as in findFundamentalMat() are supported.
F InputArray Input fundamental matrix. It can be computed from the same set /// of point pairs using findFundamentalMat() .
imgSize Size Size of the image.
H1 OutputArray Output rectification homography matrix for the first image.
H2 OutputArray Output rectification homography matrix for the second image.
threshold double 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.
return bool

Stylization() public static method

Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.
public static Stylization ( InputArray src, OutputArray dst, float sigmaS = 60, float sigmaR = 0.45f ) : void
src InputArray Input 8-bit 3-channel image.
dst OutputArray Output image with the same size and type as src.
sigmaS float Range between 0 to 200.
sigmaR float Range between 0 to 1.
return void

Subtract() public static method

Calculates per-element difference between two arrays or array and a scalar
public static Subtract ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null, int dtype = -1 ) : void
src1 InputArray The first source array
src2 InputArray The second source array. It must have the same size and same type as src1
dst OutputArray The destination array; it will have the same size and same type as src1
mask InputArray The optional operation mask, 8-bit single channel array; specifies elements of the destination array to be changed. [By default this is null]
dtype int
return void

Sum() public static method

computes sum of array elements
public static Sum ( InputArray src ) : Scalar
src InputArray The source array; must have 1 to 4 channels
return Scalar

TextureFlattening() public static method

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.
public static TextureFlattening ( InputArray src, InputArray mask, OutputArray dst, float lowThreshold = 30, float highThreshold = 45, int kernelSize = 3 ) : void
src InputArray Input 8-bit 3-channel image.
mask InputArray Input 8-bit 1 or 3-channel image.
dst OutputArray Output image with the same size and type as src.
lowThreshold float Range from 0 to 100.
highThreshold float Value > 100.
kernelSize int The size of the Sobel kernel to be used.
return void

TheRNG() public static method

returns the thread-local Random number generator
public static TheRNG ( ) : RNG
return RNG

Threshold() public static method

Applies a fixed-level threshold to each array element.
public static Threshold ( InputArray src, OutputArray dst, double thresh, double maxval, ThresholdTypes type ) : double
src InputArray input array (single-channel, 8-bit or 32-bit floating point).
dst OutputArray output array of the same size and type as src.
thresh double threshold value.
maxval double maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.
type ThresholdTypes thresholding type (see the details below).
return double

Trace() public static method

computes trace of a matrix
public static Trace ( InputArray mtx ) : Scalar
mtx InputArray The source matrix
return Scalar

Transform() public static method

performs affine transformation of each element of multi-channel input matrix
public static Transform ( InputArray src, OutputArray dst, InputArray m ) : void
src InputArray The source array; must have as many channels (1 to 4) as mtx.cols or mtx.cols-1
dst OutputArray The destination array; will have the same size and depth as src and as many channels as mtx.rows
m InputArray The transformation matrix
return void

Transpose() public static method

transposes the matrix
public static Transpose ( InputArray src, OutputArray dst ) : void
src InputArray The source array
dst OutputArray The destination array of the same type as src
return void

TriangulatePoints() public static method

Reconstructs points by triangulation.
public static TriangulatePoints ( double projMatr1, double projMatr2, IEnumerable projPoints1, IEnumerable projPoints2 ) : Vec4d[]
projMatr1 double 3x4 projection matrix of the first camera.
projMatr2 double 3x4 projection matrix of the second camera.
projPoints1 IEnumerable 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.
projPoints2 IEnumerable 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.
return Vec4d[]

TriangulatePoints() public static method

Reconstructs points by triangulation.
public static TriangulatePoints ( InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D ) : void
projMatr1 InputArray 3x4 projection matrix of the first camera.
projMatr2 InputArray 3x4 projection matrix of the second camera.
projPoints1 InputArray 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.
projPoints2 InputArray 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.
points4D OutputArray 4xN array of reconstructed points in homogeneous coordinates.
return void

Undistort() public static method

corrects lens distortion for the given camera matrix and distortion coefficients
public static Undistort ( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix = null ) : void
src InputArray Input (distorted) image.
dst OutputArray Output (corrected) image that has the same size and type as src .
cameraMatrix InputArray Input camera matrix
distCoeffs InputArray 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.
newCameraMatrix InputArray 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.
return void

UndistortPoints() public static method

Computes the ideal point coordinates from the observed point coordinates.
public static UndistortPoints ( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray r = null, InputArray p = null ) : void
src InputArray Observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or CV_64FC2).
dst OutputArray Output ideal point coordinates after undistortion and reverse perspective transformation. /// If matrix P is identity or omitted, dst will contain normalized point coordinates.
cameraMatrix InputArray Camera matrix
distCoeffs InputArray 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.
r InputArray 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.
p InputArray 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.
return void

UpdateMotionHistory() public static method

Updates motion history image using the current silhouette
public static UpdateMotionHistory ( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration ) : void
silhouette InputArray Silhouette mask that has non-zero pixels where the motion occurs.
mhi InputOutputArray Motion history image that is updated by the function (single-channel, 32-bit floating-point).
timestamp double Current time in milliseconds or other units.
duration double Maximal duration of the motion track in the same units as timestamp .
return void

UseOptimized() public static method

Returns the current optimization status. The function returns the current optimization status, which is controlled by cv::setUseOptimized().
public static UseOptimized ( ) : bool
return bool

VConcat() public static method

public static VConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void
src1 InputArray
src2 InputArray
dst OutputArray
return void

VConcat() public static method

public static VConcat ( Mat src, OutputArray dst ) : void
src Mat
dst OutputArray
return void

ValidateDisparity() public static method

validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
public static ValidateDisparity ( InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1 ) : void
disparity InputOutputArray
cost InputArray
minDisparity int
numberOfDisparities int
disp12MaxDisp int
return void

WaitKey() public static method

Waits for a pressed key.
public static WaitKey ( int delay ) : int
delay int Delay in milliseconds. 0 is the special value that means ”forever”
return int

WarpAffine() public static method

Applies an affine transformation to an image.
public static WarpAffine ( InputArray src, OutputArray dst, InputArray m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray input image.
dst OutputArray output image that has the size dsize and the same type as src.
m InputArray 2x3 transformation matrix.
dsize Size size of the output image.
flags InterpolationFlags combination of interpolation methods and the optional flag /// WARP_INVERSE_MAP that means that M is the inverse transformation (dst -> src) .
borderMode BorderTypes 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.
borderValue Scalar value used in case of a constant border; by default, it is 0.
return void

WarpPerspective() public static method

Applies a perspective transformation to an image.
public static WarpPerspective ( InputArray src, OutputArray dst, InputArray m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray input image.
dst OutputArray output image that has the size dsize and the same type as src.
m InputArray 3x3 transformation matrix.
dsize Size size of the output image.
flags InterpolationFlags 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).
borderMode BorderTypes pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
borderValue Scalar value used in case of a constant border; by default, it equals 0.
return void

WarpPerspective() public static method

Applies a perspective transformation to an image.
public static WarpPerspective ( InputArray src, OutputArray dst, float m, Size dsize, InterpolationFlags flags = InterpolationFlags.Linear, BorderTypes borderMode = BorderTypes.Constant, Scalar borderValue = null ) : void
src InputArray input image.
dst OutputArray output image that has the size dsize and the same type as src.
m float 3x3 transformation matrix.
dsize Size size of the output image.
flags InterpolationFlags 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).
borderMode BorderTypes pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
borderValue Scalar value used in case of a constant border; by default, it equals 0.
return void

Watershed() public static method

Performs a marker-based image segmentation using the watershed algorithm.
public static Watershed ( InputArray image, InputOutputArray markers ) : void
image InputArray Input 8-bit 3-channel image.
markers InputOutputArray Input/output 32-bit single-channel image (map) of markers. /// It should have the same size as image.
return void

Write() public static method

public static Write ( FileStorage fs, string name, IEnumerable value ) : void
fs FileStorage
name string
value IEnumerable
return void

Write() public static method

public static Write ( FileStorage fs, string name, IEnumerable value ) : void
fs FileStorage
name string
value IEnumerable
return void

Write() public static method

public static Write ( FileStorage fs, string name, Mat value ) : void
fs FileStorage
name string
value Mat
return void

Write() public static method

public static Write ( FileStorage fs, string name, SparseMat value ) : void
fs FileStorage
name string
value SparseMat
return void

Write() public static method

public static Write ( FileStorage fs, string name, double value ) : void
fs FileStorage
name string
value double
return void

Write() public static method

public static Write ( FileStorage fs, string name, float value ) : void
fs FileStorage
name string
value float
return void

Write() public static method

public static Write ( FileStorage fs, string name, int value ) : void
fs FileStorage
name string
value int
return void

Write() public static method

public static Write ( FileStorage fs, string name, string value ) : void
fs FileStorage
name string
value string
return void

WriteScalar() public static method

public static WriteScalar ( FileStorage fs, double value ) : void
fs FileStorage
value double
return void

WriteScalar() public static method

public static WriteScalar ( FileStorage fs, float value ) : void
fs FileStorage
value float
return void

WriteScalar() public static method

public static WriteScalar ( FileStorage fs, int value ) : void
fs FileStorage
value int
return void

WriteScalar() public static method

public static WriteScalar ( FileStorage fs, string value ) : void
fs FileStorage
value string
return void

calcOpticalFlowSF() public static method

computes dense optical flow using Simple Flow algorithm
public static calcOpticalFlowSF ( Mat from, Mat to, Mat flow, int layers, int averagingBlockSize, int maxFlow, double sigmaDist, double sigmaColor, int postprocessWindow, double sigmaDistFix, double sigmaColorFix, double occThr, int upscaleAveragingRadius, double upscaleSigmaDist, double upscaleSigmaColor, double speedUpThr ) : void
from Mat First 8-bit 3-channel image.
to Mat Second 8-bit 3-channel image
flow Mat Estimated flow
layers int Number of layers
averagingBlockSize int Size of block through which we sum up when calculate cost function for pixel
maxFlow int maximal flow that we search at each level
sigmaDist double vector smooth spatial sigma parameter
sigmaColor double vector smooth color sigma parameter
postprocessWindow int window size for postprocess cross bilateral filter
sigmaDistFix double spatial sigma for postprocess cross bilateralf filter
sigmaColorFix double color sigma for postprocess cross bilateral filter
occThr double threshold for detecting occlusions
upscaleAveragingRadius int window size for bilateral upscale operation
upscaleSigmaDist double spatial sigma for bilateral upscale operation
upscaleSigmaColor double color sigma for bilateral upscale operation
speedUpThr double threshold to detect point with irregular flow - where flow should be recalculated after upscale
return void