Méthode | Description | |
---|---|---|
AGAST ( InputArray image, int threshold, bool nonmaxSuppression, AGASTType type ) : KeyPoint[] |
Detects corners using the AGAST algorithm
|
|
Abs ( OpenCvSharp.Mat src ) : |
Computes absolute value of each matrix element
|
|
Abs ( |
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 |
Approximates contour or a curve using Douglas-Peucker algorithm
|
|
ApproxPolyDP ( IEnumerable |
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 |
Calculates a contour perimeter or a curve length.
|
|
ArcLength ( IEnumerable |
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 |
Calculates the up-right bounding rectangle of a point set.
|
|
BoundingRect ( IEnumerable |
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 |
finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
|
|
CalibrateCamera ( IEnumerable |
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 |
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
|
|
ComputeCorrespondEpilines ( IEnumerable |
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 ) : |
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 |
Calculates the contour area
|
|
ContourArea ( IEnumerable |
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 |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
|
|
ConvertPointsFromHomogeneous ( IEnumerable |
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 |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
|
|
ConvertPointsToHomogeneous ( IEnumerable |
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 |
Computes convex hull for a set of 2D points.
|
|
ConvexHull ( IEnumerable |
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 |
Computes convex hull for a set of 2D points.
|
|
ConvexHullIndices ( IEnumerable |
Computes convex hull for a set of 2D points.
|
|
ConvexityDefects ( IEnumerable |
Computes the contour convexity defects
|
|
ConvexityDefects ( IEnumerable |
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 |
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 |
Refines coordinates of corresponding points.
|
|
CountNonZero ( InputArray mtx ) : int |
computes the number of nonzero array elements
|
|
CreateCLAHE ( double clipLimit = 40.0, Size tileGridSize = null ) : |
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 |
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 |
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 |
draws contours in the image
|
|
DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable |
draws contours in the image
|
|
DrawKeypoints ( OpenCvSharp.Mat image, IEnumerable |
Draw keypoints.
|
|
DrawMatches ( OpenCvSharp.Mat img1, IEnumerable |
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 ( |
|
|
FastMalloc ( long bufSize ) : |
|
|
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 |
Modification of fastNlMeansDenoisingMulti function for colored images sequences
|
|
FastNlMeansDenoisingColoredMulti ( IEnumerable |
Modification of fastNlMeansDenoisingMulti function for colored images sequences
|
|
FastNlMeansDenoisingMulti ( IEnumerable |
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 |
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 |
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 |
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 ¢ers, 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 |
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 |
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 |
Fits ellipse to the set of 2D points.
|
|
FitEllipse ( IEnumerable |
Fits ellipse to the set of 2D points.
|
|
FitEllipse ( InputArray points ) : RotatedRect |
Fits ellipse to the set of 2D points.
|
|
FitLine ( IEnumerable |
Fits line to the set of 2D points using M-estimator algorithm
|
|
FitLine ( IEnumerable |
Fits line to the set of 2D points using M-estimator algorithm
|
|
FitLine ( IEnumerable |
Fits line to the set of 3D points using M-estimator algorithm
|
|
FitLine ( IEnumerable |
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 |
|
|
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 |
|
|
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 |
|
|
GetPerspectiveTransform ( InputArray src, InputArray dst ) : Mat |
|
|
GetRecall ( IEnumerable |
|
|
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 |
initializes camera matrix from a few 3D points and the corresponding projections.
|
|
InitCameraMatrix2D ( IEnumerable |
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 |
finds intersection of two convex polygons
|
|
IntersectConvexConvex ( IEnumerable |
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 |
returns true if the contour is convex. D oes not support contours with self-intersection
|
|
IsContourConvex ( IEnumerable |
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 |
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 |
Finds the minimum area rotated rectangle enclosing a 2D point set.
|
|
MinAreaRect ( IEnumerable |
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 |
Finds the minimum area circle enclosing a 2D point set.
|
|
MinEnclosingCircle ( IEnumerable |
Finds the minimum area circle enclosing a 2D point set.
|
|
MinEnclosingCircle ( InputArray points, Point2f ¢er, 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 |
Calculates all of the moments up to the third order of a polygon or rasterized shape.
|
|
Moments ( IEnumerable |
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 |
performs perspective transformation of each element of multi-channel input matrix
|
|
PerspectiveTransform ( IEnumerable |
performs perspective transformation of each element of multi-channel input matrix
|
|
PerspectiveTransform ( IEnumerable |
performs perspective transformation of each element of multi-channel input matrix
|
|
PerspectiveTransform ( IEnumerable |
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 |
Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary.
|
|
PointPolygonTest ( IEnumerable |
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 |
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 |
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 |
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 |
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 |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
|
|
SolvePnPRansac ( IEnumerable |
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 |
finds intrinsic and extrinsic parameters of a stereo camera
|
|
StereoCalibrate ( IEnumerable |
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 |
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 |
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 |
|
|
Write ( FileStorage fs, string name, IEnumerable |
|
|
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
|
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 |
Résultat | KeyPoint[] |
public static Abs ( OpenCvSharp.Mat src ) : |
||
src | OpenCvSharp.Mat | matrix |
Résultat |
public static Abs ( |
||
src | matrix expression | |
Résultat |
public static Absdiff ( InputArray src1, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
public static AlignSize ( int sz, int n ) : int | ||
sz | int | |
n | int | |
Résultat | int |
public static ApplyColorMap ( InputArray src, OutputArray dst, ColormapTypes colormap ) : void | ||
src | InputArray | |
dst | OutputArray | |
colormap | ColormapTypes | |
Résultat | void |
public static ApproxPolyDP ( IEnumerable |
||
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 |
Résultat | Point2f[] |
public static ApproxPolyDP ( IEnumerable |
||
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 |
Résultat | System.Point[] |
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 |
Résultat | void |
public static ArcLength ( IEnumerable |
||
curve | IEnumerable |
The input vector of 2D points. |
closed | bool | Indicates, whether the curve is closed or not. |
Résultat | double |
public static ArcLength ( IEnumerable |
||
curve | IEnumerable |
The input vector of 2D points. |
closed | bool | Indicates, whether the curve is closed or not. |
Résultat | double |
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. |
Résultat | double |
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 |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
public static BitwiseAnd ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
mask | InputArray | |
Résultat | void |
public static BitwiseNot ( InputArray src, OutputArray dst, InputArray mask = null ) : void | ||
src | InputArray | |
dst | OutputArray | |
mask | InputArray | |
Résultat | void |
public static BitwiseOr ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
mask | InputArray | |
Résultat | void |
public static BitwiseXor ( InputArray src1, InputArray src2, OutputArray dst, InputArray mask = null ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
mask | InputArray | |
Résultat | void |
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 |
Résultat | void |
public static BoundingRect ( IEnumerable |
||
curve | IEnumerable |
The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | Rect |
public static BoundingRect ( IEnumerable |
||
curve | IEnumerable |
The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | Rect |
public static BoundingRect ( InputArray curve ) : Rect | ||
curve | InputArray | The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | Rect |
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 |
Résultat | void |
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. |
Résultat | int |
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. |
Résultat | int |
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 | |
Résultat | void |
public static CalcCovarMatrix ( InputArray samples, OutputArray covar, OpenCvSharp.InputOutputArray mean, CovarFlags flags ) : void | ||
samples | InputArray | |
covar | OutputArray | |
mean | OpenCvSharp.InputOutputArray | |
flags | CovarFlags | |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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() . |
Résultat | double |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 |
Résultat | void |
public static CalibrateCamera ( IEnumerable |
||
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. |
Résultat | double |
public static CalibrateCamera ( IEnumerable |
||
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. |
Résultat | double |
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 |
Résultat | void |
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 |
Résultat | void |
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() . |
Résultat | OpenCvSharp.RotatedRect |
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] |
Résultat | void |
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 | |
Résultat | void |
public static CheckHardwareSupport ( CpuFeatures feature ) : bool | ||
feature | CpuFeatures | |
Résultat | bool |
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. |
Résultat | bool |
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 |
Résultat | bool |
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] |
Résultat | void |
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] |
Résultat | void |
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 |
Résultat | bool |
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 |
Résultat | bool |
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. |
Résultat | void |
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) |
Résultat | void |
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 |
Résultat | double |
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 |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
public static ComputeCorrespondEpilines ( IEnumerable |
||
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() . |
Résultat | Point3f[] |
public static ComputeCorrespondEpilines ( IEnumerable |
||
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() . |
Résultat | Point3f[] |
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) . |
Résultat | void |
public static ComputeRecallPrecisionCurve ( OpenCvSharp.DMatch matches1to2, byte correctMatches1to2Mask ) : Point2f[] | ||
matches1to2 | OpenCvSharp.DMatch | |
correctMatches1to2Mask | byte | |
Résultat | Point2f[] |
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 |
Résultat | int |
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. |
Résultat | int |
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 |
Résultat | int |
public static ConnectedComponentsEx ( InputArray image, PixelConnectivity connectivity = PixelConnectivity.Connectivity8 ) : |
||
image | InputArray | the image to be labeled |
connectivity | PixelConnectivity | 8 or 4 for 8-way or 4-way connectivity respectively |
Résultat |
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 |
Résultat | int |
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. |
Résultat | int |
public static ContourArea ( IEnumerable |
||
contour | IEnumerable |
The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix |
oriented | bool | |
Résultat | double |
public static ContourArea ( IEnumerable |
||
contour | IEnumerable |
The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix |
oriented | bool | |
Résultat | double |
public static ContourArea ( InputArray contour, bool oriented = false ) : double | ||
contour | InputArray | The contour vertices, represented by CV_32SC2 or CV_32FC2 matrix |
oriented | bool | |
Résultat | double |
public static ConvertImage ( OpenCvSharp.Mat src, OpenCvSharp.Mat dst, ConvertImageModes flags = ConvertImageModes.None ) : void | ||
src | OpenCvSharp.Mat | |
dst | OpenCvSharp.Mat | |
flags | ConvertImageModes | |
Résultat | void |
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 | |
Résultat | void |
public static ConvertPointsFromHomogeneous ( IEnumerable |
||
src | IEnumerable |
Input vector of N-dimensional points. |
Résultat | Vec2f[] |
public static ConvertPointsFromHomogeneous ( IEnumerable |
||
src | IEnumerable |
Input vector of N-dimensional points. |
Résultat | Vec3f[] |
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. |
Résultat | void |
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. |
Résultat | void |
public static ConvertPointsToHomogeneous ( IEnumerable |
||
src | IEnumerable |
Input vector of N-dimensional points. |
Résultat | Vec3f[] |
public static ConvertPointsToHomogeneous ( IEnumerable |
||
src | IEnumerable |
Input vector of N-dimensional points. |
Résultat | Vec4f[] |
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. |
Résultat | void |
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] |
Résultat | void |
public static ConvexHull ( IEnumerable |
||
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. |
Résultat | Point2f[] |
public static ConvexHull ( IEnumerable |
||
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. |
Résultat | System.Point[] |
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 | |
Résultat | void |
public static ConvexHullIndices ( IEnumerable |
||
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. |
Résultat | int[] |
public static ConvexHullIndices ( IEnumerable |
||
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. |
Résultat | int[] |
public static ConvexityDefects ( IEnumerable |
||
contour | IEnumerable |
Input contour. |
convexHull | IEnumerable |
Convex hull obtained using convexHull() that /// should contain indices of the contour points that make the hull. |
Résultat | Vec4i[] |
public static ConvexityDefects ( IEnumerable |
||
contour | IEnumerable |
Input contour. |
convexHull | IEnumerable |
Convex hull obtained using convexHull() that /// should contain indices of the contour points that make the hull. |
Résultat | Vec4i[] |
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. /// |
Résultat | void |
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 |
Résultat | void |
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 | |
Résultat | void |
public static CornerSubPix ( InputArray image, IEnumerable |
||
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. |
Résultat | Point2f[] |
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. |
Résultat | void |
public static CorrectMatches ( double F, IEnumerable |
||
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. |
Résultat | void |
public static CountNonZero ( InputArray mtx ) : int | ||
mtx | InputArray | Single-channel array |
Résultat | int |
public static CreateCLAHE ( double clipLimit = 40.0, Size tileGridSize = null ) : |
||
clipLimit | double | |
tileGridSize | Size | |
Résultat |
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 |
Résultat | void |
public static CreateOptFlow_DualTVL1 ( ) : OpenCvSharp.DenseOpticalFlow | ||
Résultat | OpenCvSharp.DenseOpticalFlow |
public static CubeRoot ( float val ) : float | ||
val | float | |
Résultat | float |
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 |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
public static DenoiseTVL1 ( IEnumerable |
||
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. |
Résultat | void |
public static DestroyWindow ( string winName ) : void | ||
winName | string | |
Résultat | void |
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. |
Résultat | void |
public static Determinant ( InputArray mtx ) : double | ||
mtx | InputArray | The input matrix; must have CV_32FC1 or CV_64FC1 type and square size |
Résultat | double |
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 |
Résultat | void |
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()] |
Résultat | void |
public static DistanceTransform ( InputArray src, OutputArray dst, DistanceTypes distanceType, DistanceMaskSize maskSize ) : void | ||
src | InputArray | |
dst | OutputArray | |
distanceType | DistanceTypes | |
maskSize | DistanceMaskSize | |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
public static DrawChessboardCorners ( OpenCvSharp.InputOutputArray image, Size patternSize, IEnumerable |
||
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. |
Résultat | void |
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. |
Résultat | void |
public static DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable |
||
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) |
Résultat | void |
public static DrawContours ( OpenCvSharp.InputOutputArray image, IEnumerable |
||
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) |
Résultat | void |
public static DrawKeypoints ( OpenCvSharp.Mat image, IEnumerable |
||
image | OpenCvSharp.Mat | |
keypoints | IEnumerable |
|
outImage | OpenCvSharp.Mat | |
color | Scalar | |
flags | DrawMatchesFlags | |
Résultat | void |
public static DrawMatches ( OpenCvSharp.Mat img1, IEnumerable |
||
img1 | OpenCvSharp.Mat | |
keypoints1 | IEnumerable |
|
img2 | OpenCvSharp.Mat | |
keypoints2 | IEnumerable |
|
matches1To2 | IEnumerable |
|
outImg | OpenCvSharp.Mat | |
matchColor | Scalar | |
singlePointColor | Scalar | |
matchesMask | IEnumerable |
|
flags | DrawMatchesFlags | |
Résultat | void |
public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType ) : float | ||
signature1 | InputArray | |
signature2 | InputArray | |
distType | DistanceTypes | |
Résultat | float |
public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost ) : float | ||
signature1 | InputArray | |
signature2 | InputArray | |
distType | DistanceTypes | |
cost | InputArray | |
Résultat | float |
public static EMD ( InputArray signature1, InputArray signature2, DistanceTypes distType, InputArray cost, float &lowerBound ) : float | ||
signature1 | InputArray | |
signature2 | InputArray | |
distType | DistanceTypes | |
cost | InputArray | |
lowerBound | float | |
Résultat | float |
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 | |
Résultat | float |
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. |
Résultat | void |
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 |
Résultat | bool |
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] |
Résultat | void |
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] |
Résultat | void |
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 |
Résultat | System.Point[] |
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 |
Résultat | void |
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()] |
Résultat | void |
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. |
Résultat | int |
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). |
Résultat | OpenCvSharp.Mat |
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 | |
Résultat | void |
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 |
Résultat | void |
public static ExtractChannel ( InputArray src, OutputArray dst, int coi ) : void | ||
src | InputArray | |
dst | OutputArray | |
coi | int | |
Résultat | void |
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). |
Résultat | KeyPoint[] |
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 |
Résultat | KeyPoint[] |
public static FastAtan2 ( float y, float x ) : float | ||
y | float | |
x | float | |
Résultat | float |
public static FastFree ( |
||
ptr | ||
Résultat | void |
public static FastMalloc ( long bufSize ) : |
||
bufSize | long | |
Résultat |
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 |
Résultat | void |
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 |
Résultat | void |
public static FastNlMeansDenoisingColoredMulti ( IEnumerable |
||
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 |
Résultat | void |
public static FastNlMeansDenoisingColoredMulti ( IEnumerable |
||
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 |
Résultat | void |
public static FastNlMeansDenoisingMulti ( IEnumerable |
||
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 |
Résultat | void |
public static FastNlMeansDenoisingMulti ( IEnumerable |
||
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 |
Résultat | void |
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 |
Résultat | void |
public static FillConvexPoly ( OpenCvSharp.Mat img, IEnumerable |
||
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 |
Résultat | void |
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 | |
Résultat | void |
public static FillPoly ( OpenCvSharp.Mat img, IEnumerable |
||
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 | |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
public static Find4QuadCornerSubpix ( InputArray img, OpenCvSharp.InputOutputArray corners, Size regionSize ) : bool | ||
img | InputArray | |
corners | OpenCvSharp.InputOutputArray | |
regionSize | Size | |
Résultat | bool |
public static Find4QuadCornerSubpix ( InputArray img, [ corners, Size regionSize ) : bool | ||
img | InputArray | |
corners | [ | |
regionSize | Size | |
Résultat | bool |
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 |
Résultat | bool |
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 |
Résultat | bool |
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. |
Résultat | bool |
public static FindCirclesGrid ( InputArray image, Size patternSize, Point2f ¢ers, 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. |
Résultat | bool |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | Point[][] |
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. |
Résultat | MatOfPoint[] |
public static FindFundamentalMat ( IEnumerable |
||
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. |
Résultat | Mat |
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. |
Résultat | Mat |
public static FindHomography ( IEnumerable |
||
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. |
Résultat | Mat |
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. |
Résultat | Mat |
public static FindNonZero ( InputArray src, OutputArray idx ) : void | ||
src | InputArray | |
idx | OutputArray | |
Résultat | void |
public static FitEllipse ( IEnumerable |
||
points | IEnumerable |
Input 2D point set |
Résultat | RotatedRect |
public static FitEllipse ( IEnumerable |
||
points | IEnumerable |
Input 2D point set |
Résultat | RotatedRect |
public static FitEllipse ( InputArray points ) : RotatedRect | ||
points | InputArray | Input 2D point set |
Résultat | RotatedRect |
public static FitLine ( IEnumerable |
||
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. |
Résultat | Line2D |
public static FitLine ( IEnumerable |
||
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. |
Résultat | Line2D |
public static FitLine ( IEnumerable |
||
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. |
Résultat | Line3D |
public static FitLine ( IEnumerable |
||
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. |
Résultat | Line3D |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | int |
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. |
Résultat | int |
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. |
Résultat | int |
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. |
Résultat | int |
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 |
Résultat | void |
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 | |
Résultat | void |
public static GetAffineTransform ( IEnumerable |
||
src | IEnumerable |
|
dst | IEnumerable |
|
Résultat | Mat |
public static GetAffineTransform ( InputArray src, InputArray dst ) : Mat | ||
src | InputArray | |
dst | InputArray | |
Résultat | Mat |
public static GetBuildInformation ( ) : string | ||
Résultat | string |
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. |
Résultat | Mat |
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. |
Résultat | void |
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 | |
Résultat | Mat |
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. |
Résultat | Mat |
public static GetNearestPoint ( IEnumerable |
||
recallPrecisionCurve | IEnumerable |
|
lPrecision | float | |
Résultat | int |
public static GetOptimalDFTSize ( int vecsize ) : int | ||
vecsize | int | |
Résultat | int |
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. |
Résultat | Mat |
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. |
Résultat | ].double[ |
public static GetPerspectiveTransform ( IEnumerable |
||
src | IEnumerable |
|
dst | IEnumerable |
|
Résultat | Mat |
public static GetPerspectiveTransform ( InputArray src, InputArray dst ) : Mat | ||
src | InputArray | |
dst | InputArray | |
Résultat | Mat |
public static GetRecall ( IEnumerable |
||
recallPrecisionCurve | IEnumerable |
|
lPrecision | float | |
Résultat | float |
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. |
Résultat | void |
public static GetRotationMatrix2D ( Point2f center, double angle, double scale ) : Mat | ||
center | Point2f | |
angle | double | |
scale | double | |
Résultat | Mat |
public static GetStructuringElement ( MorphShapes shape, Size ksize ) : Mat | ||
shape | MorphShapes | |
ksize | Size | |
Résultat | Mat |
public static GetStructuringElement ( MorphShapes shape, Size ksize, Point anchor ) : Mat | ||
shape | MorphShapes | |
ksize | Size | |
anchor | Point | |
Résultat | Mat |
public static GetTextSize ( string text, HersheyFonts fontFace, double fontScale, int thickness, int &baseLine ) : Size | ||
text | string | |
fontFace | HersheyFonts | |
fontScale | double | |
thickness | int | |
baseLine | int | |
Résultat | Size |
public static GetTickFrequency ( ) : double | ||
Résultat | double |
public static GetValidDisparityROI ( Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize ) : Rect | ||
roi1 | Rect | |
roi2 | Rect | |
minDisparity | int | |
numberOfDisparities | int | |
SADWindowSize | int | |
Résultat | Rect |
public static GetWindowProperty ( string winName, WindowProperty propId ) : double | ||
winName | string | Name of the window. |
propId | WindowProperty | Window property to retrieve. |
Résultat | double |
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. |
Résultat | Point2f[] |
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. |
Résultat | void |
public static HConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
public static HConcat ( Mat src, OutputArray dst ) : void | ||
src | Mat | |
dst | OutputArray | |
Résultat | void |
public static HaveImageReader ( string fileName ) : bool | ||
fileName | string | |
Résultat | bool |
public static HaveImageWriter ( string fileName ) : bool | ||
fileName | string | |
Résultat | bool |
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] |
Résultat | CircleSegment[] |
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] |
Résultat | LineSegmentPolar[] |
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] |
Résultat | LineSegmentPoint[] |
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 |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
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 |
Résultat | Mat |
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 |
Résultat | Mat |
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 |
Résultat | Mat |
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. |
Résultat | bool |
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. |
Résultat | void |
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 |
Résultat | Mat |
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. |
Résultat | bool |
public static ImShow ( string winname, Mat mat ) : void | ||
winname | string | Name of the window. |
mat | Mat | Image to be shown. |
Résultat | void |
public static ImWrite ( string fileName, Mat img ) : bool | ||
fileName | string | Name of the file. |
img | Mat | Image to be saved. |
Résultat | bool |
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 |
Résultat | bool |
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 |
Résultat | void |
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 |
Résultat | void |
public static InitCameraMatrix2D ( IEnumerable |
||
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 . |
Résultat | Mat |
public static InitCameraMatrix2D ( IEnumerable |
||
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 . |
Résultat | Mat |
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 | |
Résultat | void |
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 | |
Résultat | float |
public static Inpaint ( InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, InpaintMethod flags ) : void | ||
src | InputArray | |
inpaintMask | InputArray | |
dst | OutputArray | |
inpaintRadius | double | |
flags | InpaintMethod | |
Résultat | void |
public static InsertChannel ( InputArray src, InputOutputArray dst, int coi ) : void | ||
src | InputArray | |
dst | InputOutputArray | |
coi | int | |
Résultat | void |
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 | |
Résultat | void |
public static Integral ( InputArray src, OutputArray sum, OutputArray sqsum, int sdepth = -1 ) : void | ||
src | InputArray | |
sum | OutputArray | |
sqsum | OutputArray | |
sdepth | int | |
Résultat | void |
public static Integral ( InputArray src, OutputArray sum, int sdepth = -1 ) : void | ||
src | InputArray | |
sum | OutputArray | |
sdepth | int | |
Résultat | void |
public static IntersectConvexConvex ( IEnumerable |
||
p1 | IEnumerable |
|
p2 | IEnumerable |
|
p12 | Point2f | |
handleNested | bool | |
Résultat | float |
public static IntersectConvexConvex ( IEnumerable |
||
p1 | IEnumerable |
|
p2 | IEnumerable |
|
p12 | Point | |
handleNested | bool | |
Résultat | float |
public static IntersectConvexConvex ( InputArray p1, InputArray p2, OutputArray p12, bool handleNested = true ) : float | ||
p1 | InputArray | |
p2 | InputArray | |
p12 | OutputArray | |
handleNested | bool | |
Résultat | float |
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 |
Résultat | double |
public static InvertAffineTransform ( InputArray m, OutputArray im ) : void | ||
m | InputArray | Original affine transformation. |
im | OutputArray | Output reverse affine transformation. |
Résultat | void |
public static IsContourConvex ( IEnumerable |
||
contour | IEnumerable |
Input vector of 2D points |
Résultat | bool |
public static IsContourConvex ( IEnumerable |
||
contour | IEnumerable |
Input vector of 2D points |
Résultat | bool |
public static IsContourConvex ( InputArray contour ) : bool | ||
contour | InputArray | Input vector of 2D points |
Résultat | bool |
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 | |
Résultat | double |
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 | |
Résultat | void |
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 | |
Résultat | void |
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 |
Résultat | void |
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] |
Résultat | void |
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] |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
public static Magnitude ( InputArray x, InputArray y, OutputArray magnitude ) : void | ||
x | InputArray | |
y | InputArray | |
magnitude | OutputArray | |
Résultat | void |
public static Mahalanobis ( InputArray v1, InputArray v2, InputArray icovar ) : double | ||
v1 | InputArray | |
v2 | InputArray | |
icovar | InputArray | |
Résultat | double |
public static Mahalonobis ( InputArray v1, InputArray v2, InputArray icovar ) : double | ||
v1 | InputArray | |
v2 | InputArray | |
icovar | InputArray | |
Résultat | double |
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 . |
Résultat | void |
public static MatchShapes ( IEnumerable |
||
contour1 | IEnumerable |
|
contour2 | IEnumerable |
|
method | ShapeMatchModes | |
parameter | double | |
Résultat | double |
public static MatchShapes ( InputArray contour1, InputArray contour2, ShapeMatchModes method, double parameter ) : double | ||
contour1 | InputArray | |
contour2 | InputArray | |
method | ShapeMatchModes | |
parameter | double | |
Résultat | double |
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. |
Résultat | void |
public static Max ( InputArray src1, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
public static Max ( Mat src1, Mat src2, Mat dst ) : void | ||
src1 | Mat | |
src2 | Mat | |
dst | Mat | |
Résultat | void |
public static Max ( Mat src1, double src2, Mat dst ) : void | ||
src1 | Mat | |
src2 | double | |
dst | Mat | |
Résultat | void |
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 |
Résultat | Scalar |
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. |
Résultat | int |
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 |
Résultat | void |
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 |
Résultat | void |
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 ... |
Résultat | void |
public static Merge ( Mat mv, Mat dst ) : void | ||
mv | Mat | |
dst | Mat | |
Résultat | void |
public static Min ( InputArray src1, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
public static Min ( Mat src1, Mat src2, Mat dst ) : void | ||
src1 | Mat | |
src2 | Mat | |
dst | Mat | |
Résultat | void |
public static Min ( Mat src1, double src2, Mat dst ) : void | ||
src1 | Mat | |
src2 | double | |
dst | Mat | |
Résultat | void |
public static MinAreaRect ( IEnumerable |
||
points | IEnumerable |
The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | RotatedRect |
public static MinAreaRect ( IEnumerable |
||
points | IEnumerable |
The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | RotatedRect |
public static MinAreaRect ( InputArray points ) : RotatedRect | ||
points | InputArray | The input 2D point set, represented by CV_32SC2 or CV_32FC2 matrix. |
Résultat | RotatedRect |
public static MinEnclosingCircle ( IEnumerable |
||
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 |
Résultat | void |
public static MinEnclosingCircle ( IEnumerable |
||
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 |
Résultat | void |
public static MinEnclosingCircle ( InputArray points, Point2f ¢er, 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 |
Résultat | void |
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 |
Résultat | void |
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 | |
Résultat | void |
public static MinMaxIdx ( InputArray src, int &minIdx, int &maxIdx ) : void | ||
src | InputArray | The source single-channel array |
minIdx | int | |
maxIdx | int | |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
public static MixChannels ( Mat src, Mat dst, int fromTo ) : void | ||
src | Mat | |
dst | Mat | |
fromTo | int | |
Résultat | void |
public static Moments ( IEnumerable |
||
array | IEnumerable |
Array of 2D points |
binaryImage | bool | If it is true, then all the non-zero image pixels are treated as 1’s |
Résultat | Moments |
public static Moments ( IEnumerable |
||
array | IEnumerable |
Array of 2D points |
binaryImage | bool | If it is true, then all the non-zero image pixels are treated as 1’s |
Résultat | Moments |
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 |
Résultat | Moments |
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 |
Résultat | Moments |
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 |
Résultat | Moments |
public static MorphologyDefaultBorderValue ( ) : Scalar | ||
Résultat | Scalar |
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()] |
Résultat | void |
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 |
Résultat | void |
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 | |
Résultat | void |
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 |
Résultat | void |
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 | |
Résultat | void |
public static NamedWindow ( string winname ) : void | ||
winname | string | Name of the window in the window caption that may be used as a window identifier. |
Résultat | void |
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. /// |
Résultat | void |
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 |
Résultat | double |
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 |
Résultat | double |
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 |
Résultat | void |
public static PCABackProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void | ||
data | InputArray | |
mean | InputArray | |
eigenvectors | InputArray | |
result | OutputArray | |
Résultat | void |
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. |
Résultat | void |
public static PCAComputeVar ( InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance ) : void | ||
data | InputArray | |
mean | InputOutputArray | |
eigenvectors | OutputArray | |
retainedVariance | double | |
Résultat | void |
public static PCAProject ( InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result ) : void | ||
data | InputArray | |
mean | InputArray | |
eigenvectors | InputArray | |
result | OutputArray | |
Résultat | void |
public static PSNR ( InputArray src1, InputArray src2 ) : double | ||
src1 | InputArray | |
src2 | InputArray | |
Résultat | double |
public static PatchNaNs ( InputOutputArray a, double val ) : void | ||
a | InputOutputArray | |
val | double | |
Résultat | void |
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. |
Résultat | void |
public static PerspectiveTransform ( IEnumerable |
||
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 |
Résultat | Point2d[] |
public static PerspectiveTransform ( IEnumerable |
||
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 |
Résultat | Point2f[] |
public static PerspectiveTransform ( IEnumerable |
||
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 |
Résultat | Point3d[] |
public static PerspectiveTransform ( IEnumerable |
||
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 |
Résultat | Point3f[] |
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 |
Résultat | void |
public static Phase ( InputArray x, InputArray y, OutputArray angle, bool angleInDegrees = false ) : void | ||
x | InputArray | |
y | InputArray | |
angle | OutputArray | |
angleInDegrees | bool | |
Résultat | void |
public static PhaseCorrelate ( InputArray src1, InputArray src2, InputArray window = null ) : Point2d | ||
src1 | InputArray | |
src2 | InputArray | |
window | InputArray | |
Résultat | Point2d |
public static PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window ) : Point2d | ||
src1 | InputArray | |
src2 | InputArray | |
window | InputArray | |
Résultat | Point2d |
public static PhaseCorrelateRes ( InputArray src1, InputArray src2, InputArray window, double &response ) : Point2d | ||
src1 | InputArray | |
src2 | InputArray | |
window | InputArray | |
response | double | |
Résultat | Point2d |
public static PointPolygonTest ( IEnumerable |
||
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. |
Résultat | double |
public static PointPolygonTest ( IEnumerable |
||
contour | IEnumerable |
|
pt | Point2f | |
measureDist | bool | |
Résultat | double |
public static PointPolygonTest ( InputArray contour, Point2f pt, bool measureDist ) : double | ||
contour | InputArray | |
pt | Point2f | |
measureDist | bool | |
Résultat | double |
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 | |
Résultat | void |
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 | |
Résultat | void |
public static Polylines ( Mat img, IEnumerable |
||
img | Mat | |
pts | IEnumerable |
|
isClosed | bool | |
color | Scalar | |
thickness | int | |
lineType | LineTypes | |
shift | int | |
Résultat | void |
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 |
Résultat | void |
public static PreCornerDetect ( InputArray src, OutputArray dst, int ksize, BorderTypes borderType = BorderTypes.Default ) : void | ||
src | InputArray | |
dst | OutputArray | |
ksize | int | |
borderType | BorderTypes | |
Résultat | void |
public static ProjectPoints ( IEnumerable |
||
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. |
Résultat | void |
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. |
Résultat | void |
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 | |
Résultat | void |
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 | |
Résultat | void |
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. |
Résultat | void |
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 | |
Résultat | void |
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. |
Résultat | Vec3d |
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. |
Résultat | Vec3d |
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. |
Résultat | Vec3d |
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. |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
public static ReadDMatches ( FileNode node ) : DMatch[] | ||
node | FileNode | |
Résultat | DMatch[] |
public static ReadDouble ( FileNode node, double defaultValue = default(double) ) : double | ||
node | FileNode | |
defaultValue | double | |
Résultat | double |
public static ReadFloat ( FileNode node, float defaultValue = default(float) ) : float | ||
node | FileNode | |
defaultValue | float | |
Résultat | float |
public static ReadInt ( FileNode node, int defaultValue = default(int) ) : int | ||
node | FileNode | |
defaultValue | int | |
Résultat | int |
public static ReadKeyPoints ( FileNode node ) : KeyPoint[] | ||
node | FileNode | |
Résultat | KeyPoint[] |
public static ReadMat ( FileNode node, Mat defaultMat = null ) : Mat | ||
node | FileNode | |
defaultMat | Mat | |
Résultat | Mat |
public static ReadSparseMat ( FileNode node, SparseMat defaultMat = null ) : SparseMat | ||
node | FileNode | |
defaultMat | SparseMat | |
Résultat | SparseMat |
public static ReadString ( FileNode node, string defaultValue = default(string) ) : string | ||
node | FileNode | |
defaultValue | string | |
Résultat | string |
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] |
Résultat | void |
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] |
Résultat | void |
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] |
Résultat | void |
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] |
Résultat | void |
public static Rectify3Collinear ( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, IEnumerable |
||
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 | |
Résultat | float |
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()) |
Résultat | void |
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. |
Résultat | void |
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 |
Résultat | Mat |
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 |
Résultat | void |
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. |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
public static Rodrigues ( double vector, double &matrix ) : void | ||
vector | double | Input rotation vector (3x1). |
matrix | double | Output rotation matrix (3x3). |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | RectanglesIntersectTypes |
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. |
Résultat | RectanglesIntersectTypes |
public static SVBackSubst ( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ) : void | ||
w | InputArray | |
u | InputArray | |
vt | InputArray | |
rhs | InputArray | |
dst | OutputArray | |
Résultat | void |
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 | |
Résultat | void |
public static ScaleAdd ( InputArray src1, double alpha, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
alpha | double | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | void |
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. |
Résultat | void |
public static SetNumThreads ( int nthreads ) : void | ||
nthreads | int | |
Résultat | void |
public static SetUseOptimized ( bool onoff ) : void | ||
onoff | bool | |
Résultat | void |
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. |
Résultat | void |
public static SetWindowTitle ( string winname, string title ) : void | ||
winname | string | |
title | string | |
Résultat | void |
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 |
Résultat | void |
public static Solve ( InputArray src1, InputArray src2, OutputArray dst, DecompTypes flags = DecompTypes.LU ) : bool | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
flags | DecompTypes | |
Résultat | bool |
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 |
Résultat | int |
public static SolvePnP ( IEnumerable |
||
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: |
Résultat | void |
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: |
Résultat | void |
public static SolvePnPRansac ( IEnumerable |
||
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. |
Résultat | void |
public static SolvePnPRansac ( IEnumerable |
||
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 |
Résultat | void |
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 |
Résultat | void |
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 |
Résultat | double |
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 |
Résultat | void |
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 |
Résultat | void |
public static Split ( Mat src ) : Mat[] | ||
src | Mat | The source multi-channel array |
Résultat | Mat[] |
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 |
Résultat | void |
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 |
Résultat | void |
public static StereoCalibrate ( IEnumerable |
||
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. |
Résultat | double |
public static StereoCalibrate ( IEnumerable |
||
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. |
Résultat | double |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
public static StereoRectifyUncalibrated ( IEnumerable |
||
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. |
Résultat | bool |
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. |
Résultat | bool |
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. |
Résultat | void |
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 | |
Résultat | void |
public static Sum ( InputArray src ) : Scalar | ||
src | InputArray | The source array; must have 1 to 4 channels |
Résultat | Scalar |
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. |
Résultat | void |
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). |
Résultat | double |
public static Trace ( InputArray mtx ) : Scalar | ||
mtx | InputArray | The source matrix |
Résultat | Scalar |
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 |
Résultat | void |
public static Transpose ( InputArray src, OutputArray dst ) : void | ||
src | InputArray | The source array |
dst | OutputArray | The destination array of the same type as src |
Résultat | void |
public static TriangulatePoints ( double projMatr1, double projMatr2, IEnumerable |
||
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. |
Résultat | Vec4d[] |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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 . |
Résultat | void |
public static VConcat ( InputArray src1, InputArray src2, OutputArray dst ) : void | ||
src1 | InputArray | |
src2 | InputArray | |
dst | OutputArray | |
Résultat | void |
public static VConcat ( Mat src, OutputArray dst ) : void | ||
src | Mat | |
dst | OutputArray | |
Résultat | void |
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 | |
Résultat | void |
public static WaitKey ( int delay ) : int | ||
delay | int | Delay in milliseconds. 0 is the special value that means ”forever” |
Résultat | int |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
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. |
Résultat | void |
public static Write ( FileStorage fs, string name, IEnumerable |
||
fs | FileStorage | |
name | string | |
value | IEnumerable |
|
Résultat | void |
public static Write ( FileStorage fs, string name, IEnumerable |
||
fs | FileStorage | |
name | string | |
value | IEnumerable |
|
Résultat | void |
public static Write ( FileStorage fs, string name, Mat value ) : void | ||
fs | FileStorage | |
name | string | |
value | Mat | |
Résultat | void |
public static Write ( FileStorage fs, string name, SparseMat value ) : void | ||
fs | FileStorage | |
name | string | |
value | SparseMat | |
Résultat | void |
public static Write ( FileStorage fs, string name, double value ) : void | ||
fs | FileStorage | |
name | string | |
value | double | |
Résultat | void |
public static Write ( FileStorage fs, string name, float value ) : void | ||
fs | FileStorage | |
name | string | |
value | float | |
Résultat | void |
public static Write ( FileStorage fs, string name, int value ) : void | ||
fs | FileStorage | |
name | string | |
value | int | |
Résultat | void |
public static Write ( FileStorage fs, string name, string value ) : void | ||
fs | FileStorage | |
name | string | |
value | string | |
Résultat | void |
public static WriteScalar ( FileStorage fs, double value ) : void | ||
fs | FileStorage | |
value | double | |
Résultat | void |
public static WriteScalar ( FileStorage fs, float value ) : void | ||
fs | FileStorage | |
value | float | |
Résultat | void |
public static WriteScalar ( FileStorage fs, int value ) : void | ||
fs | FileStorage | |
value | int | |
Résultat | void |
public static WriteScalar ( FileStorage fs, string value ) : void | ||
fs | FileStorage | |
value | string | |
Résultat | void |
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 |
Résultat | void |