Class Cv2

AlignSize(int, 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, OutputArray, ColormapTypes): Applies a GNU Octave/MATLAB equivalent colormap on a given image.

ApplyColorMap(InputArray, OutputArray, InputArray): Applies a user colormap on a given image.

ApproxPolyDP(InputArray, OutputArray, double, bool): Approximates contour or a curve using Douglas-Peucker algorithm

ApproxPolyDP(IEnumerable<Point2f>, double, bool): Approximates contour or a curve using Douglas-Peucker algorithm

ApproxPolyDP(IEnumerable<Point>, double, bool): Approximates contour or a curve using Douglas-Peucker algorithm

ApproxPolyN(InputArray, OutputArray, int, float, bool): Approximates a polygon with a convex hull with a specified accuracy and number of sides.

ArcLength(InputArray, bool): Calculates a contour perimeter or a curve length.

ArcLength(IEnumerable<Point2f>, bool): Calculates a contour perimeter or a curve length.

ArcLength(IEnumerable<Point>, bool): Calculates a contour perimeter or a curve length.

ArrowedLine(InputOutputArray, Point, Point, Scalar, int, LineTypes, int, double): 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, InputArray, OutputArray, int, OutputArray, NormTypes, int, InputArray, int, bool): naive nearest neighbor finder

BilateralFilter(InputArray, OutputArray, int, double, double, BorderTypes): Applies bilateral filter to the image

BitwiseAnd(InputArray, InputArray, OutputArray, InputArray): computes bitwise conjunction of the two arrays (dst = src1 & src2)

BitwiseNot(InputArray, OutputArray, InputArray): inverts each bit of array (dst = ~src)

BitwiseOr(InputArray, InputArray, OutputArray, InputArray): computes bitwise disjunction of the two arrays (dst = src1 | src2)

BitwiseXor(InputArray, InputArray, OutputArray, InputArray): computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)

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

Blur(InputArray, OutputArray, Size, Point?, BorderTypes): Smoothes image using normalized box filter

BorderInterpolate(int, int, BorderTypes): Computes the source location of an extrapolated pixel.

BoundingRect(InputArray): Calculates the up-right bounding rectangle of a point set.

BoundingRect(IEnumerable<Point2f>): Calculates the up-right bounding rectangle of a point set.

BoundingRect(IEnumerable<Point>): Calculates the up-right bounding rectangle of a point set.

BoxFilter(InputArray, OutputArray, MatType, Size, Point?, bool, BorderTypes): Smoothes image using box filter

BoxPoints(RotatedRect)

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

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

BoxPoints(RotatedRect, OutputArray)

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

Broadcast(InputArray, InputArray, OutputArray): Broadcasts the given array to the given shape.

BuildMST(int, MSTEdge[], MSTAlgorithm, int)

Builds a Minimum Spanning Tree (MST) using the specified algorithm.

Supports graphs with negative edge weights. Self-loop edges (edges where source and target are the same) are ignored. If multiple edges exist between the same pair of nodes, only the one with the lowest weight is considered. If the graph is disconnected or input is invalid, the function returns false.

BuildOpticalFlowPyramid(InputArray, out Mat[], Size, int, bool, BorderTypes, BorderTypes, bool): Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

BuildOpticalFlowPyramid(InputArray, OutputArray, Size, int, bool, BorderTypes, BorderTypes, bool): Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

BuildPyramid(InputArray, VectorOfMat, int, BorderTypes)

CalcBackProject(Mat[], int[], InputArray, OutputArray, Rangef[], bool): computes the joint dense histogram for a set of images.

CalcCovarMatrix(InputArray, OutputArray, InputOutputArray, CovarFlags, MatType?): computes covariation matrix of a set of samples

CalcCovarMatrix(ReadOnlySpan<Mat>, Mat, Mat, CovarFlags, MatType?): computes covariation matrix of a set of samples

CalcHist(Mat[], int[], InputArray, OutputArray, int, int[], Rangef[], bool, bool): computes the joint dense histogram for a set of images.

CalcHist(Mat[], int[], InputArray, OutputArray, int, int[], float[][], bool, bool): computes the joint dense histogram for a set of images.

CalcOpticalFlowFarneback(InputArray, InputArray, InputOutputArray, double, int, int, int, int, double, OpticalFlowFlags): Computes a dense optical flow using the Gunnar Farneback's algorithm.

CalcOpticalFlowPyrLK(InputArray, InputArray, InputArray, InputOutputArray, OutputArray, OutputArray, Size?, int, TermCriteria?, OpticalFlowFlags, double): computes sparse optical flow using multi-scale Lucas-Kanade algorithm

CalcOpticalFlowPyrLK(InputArray, InputArray, Point2f[], ref Point2f[], out byte[], out float[], Size?, int, TermCriteria?, OpticalFlowFlags, double): computes sparse optical flow using multi-scale Lucas-Kanade algorithm

CalibrateCamera(IEnumerable<Mat>, IEnumerable<Mat>, Size, InputOutputArray, InputOutputArray, out Mat[], out Mat[], CalibrationFlags, TermCriteria?): finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

CalibrateCamera(IEnumerable<IEnumerable<Point3f>>, IEnumerable<IEnumerable<Point2f>>, Size, double[,], double[], out Vec3d[], out Vec3d[], CalibrationFlags, TermCriteria?): finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

CalibrateCameraRO(IEnumerable<Mat>, IEnumerable<Mat>, Size, int, InputOutputArray, InputOutputArray, out Mat[], out Mat[], OutputArray, CalibrationFlags, TermCriteria?): Finds intrinsic and extrinsic camera parameters, additionally allowing one point of the calibration pattern object to be optimized ("releasing object" method). Useful when the calibration pattern is not perfectly rigid/planar.

CalibrateHandEye(IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, OutputArray, OutputArray, HandEyeCalibrationMethod)

Computes Hand-Eye calibration.

The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation(separable solutions) and the following methods are implemented:

R.Tsai, R.Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
F.Park, B.Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
R.Horaud, F.Dornaika Hand-Eye Calibration \cite Horaud95

Another approach consists in estimating simultaneously the rotation and the translation(simultaneous solutions), with the following implemented method:

N.Andreff, R.Horaud, B.Espiau On-line Hand-Eye Calibration \cite Andreff99
K.Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98

CalibrateMultiview(IEnumerable<Mat>, IReadOnlyList<IReadOnlyList<Mat>>, IEnumerable<Size>, InputArray, InputArray, out Mat[], out Mat[], out Mat[], out Mat[], InputArray, CalibrationFlags, TermCriteria?): Estimates intrinsics and extrinsics (camera poses) for a multi-camera system, a.k.a. multi-view calibration (OpenCV 5).

CalibrateRobotWorldHandEye(IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, OutputArray, OutputArray, OutputArray, OutputArray, RobotWorldHandEyeCalibrationMethod)

Computes Robot-World/Hand-Eye calibration. The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation(separable solutions):

M.Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR

CalibrateRobotWorldHandEye(IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, IEnumerable<Mat>, out double[,], out double[], out double[,], out double[], RobotWorldHandEyeCalibrationMethod)

omputes Robot-World/Hand-Eye calibration. The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation(separable solutions):

M.Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR

CalibrationMatrixValues(InputArray, Size, double, double, out double, out double, out double, out Point2d, out double): computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

CalibrationMatrixValues(double[,], Size, double, double, out double, out double, out double, out Point2d, out double): computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

CamShift(InputArray, ref Rect, TermCriteria): Finds an object center, size, and orientation.

Canny(InputArray, InputArray, OutputArray, double, double, bool): Finds edges in an image using the Canny algorithm with custom image gradient.

Canny(InputArray, OutputArray, double, double, int, bool): Finds edges in an image using Canny algorithm.

CartToPolar(InputArray, InputArray, OutputArray, OutputArray, bool): Calculates the magnitude and angle of 2D vectors.

CheckChessboard(InputArray, Size): Checks whether the image contains chessboard of the specific size or not.

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

CheckRange(InputArray, bool): checks that each matrix element is within the specified range.

CheckRange(InputArray, bool, out Point, double, double): checks that each matrix element is within the specified range.

Circle(InputOutputArray, Point, int, Scalar, int, LineTypes, int): Draws a circle

Circle(InputOutputArray, int, int, int, Scalar, int, LineTypes, int): Draws a circle

ClipLine(Rect, ref Point, ref Point): Clips the line against the image rectangle

ClipLine(Size, ref Point, ref Point): Clips the line against the image rectangle

ColorChange(InputArray, InputArray, OutputArray, float, float, float): 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, InputArray, OutputArray, CmpTypes): Performs the per-element comparison of two arrays or an array and scalar value.

CompareHist(InputArray, InputArray, HistCompMethods): compares two histograms stored in dense arrays

CompleteSymm(InputOutputArray, bool): extends the symmetrical matrix from the lower half or from the upper half

ComposeRT(InputArray, InputArray, InputArray, InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray): composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

ComposeRT(double[], double[], double[], double[], out double[], out double[]): composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

ComposeRT(double[], double[], double[], double[], out double[], out double[], out double[,], out double[,], out double[,], out double[,], out double[,], out double[,], out double[,], out double[,]): composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

ComputeCorrespondEpilines(InputArray, int, InputArray, OutputArray): For points in an image of a stereo pair, computes the corresponding epilines in the other image.

ComputeCorrespondEpilines(IEnumerable<Point2d>, int, double[,]): For points in an image of a stereo pair, computes the corresponding epilines in the other image.

ComputeCorrespondEpilines(IEnumerable<Point3d>, int, double[,]): For points in an image of a stereo pair, computes the corresponding epilines in the other image.

ComputeECC(InputArray, InputArray, InputArray): Computes the Enhanced Correlation Coefficient value between two images @cite EP08 .

ComputeRecallPrecisionCurve(DMatch[][], byte[][])

ConnectedComponents(InputArray, OutputArray, PixelConnectivity): 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, OutputArray, PixelConnectivity, MatType): 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, out int[,], PixelConnectivity): 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, PixelConnectivity, ConnectedComponentsAlgorithmsTypes, MatType?): 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.

ConnectedComponentsWithAlgorithm(InputArray, OutputArray, PixelConnectivity, MatType, ConnectedComponentsAlgorithmsTypes)

Computes the connected components labeled image of boolean image.

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

ConnectedComponentsWithStats(InputArray, OutputArray, OutputArray, OutputArray, PixelConnectivity): 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, OutputArray, OutputArray, OutputArray, PixelConnectivity, MatType): 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.

ConnectedComponentsWithStatsWithAlgorithm(InputArray, OutputArray, OutputArray, OutputArray, PixelConnectivity, MatType, ConnectedComponentsAlgorithmsTypes)

computes the connected components labeled image of boolean image and also produces a statistics output for each label.

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

ContourArea(InputArray, bool): Calculates the contour area

ContourArea(IEnumerable<Point2f>, bool): Calculates the contour area

ContourArea(IEnumerable<Point>, bool): Calculates the contour area

ConvertMaps(InputArray, InputArray, OutputArray, OutputArray, MatType, bool): Converts image transformation maps from one representation to another.

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

ConvertPointsFromHomogeneous(IEnumerable<Vec3f>): converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

ConvertPointsFromHomogeneous(IEnumerable<Vec4f>): converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

ConvertPointsHomogeneous(InputArray, OutputArray): Converts points to/from homogeneous coordinates.

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

ConvertPointsToHomogeneous(IEnumerable<Vec2f>): converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

ConvertPointsToHomogeneous(IEnumerable<Vec3f>): converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

ConvertScaleAbs(InputArray, OutputArray, double, double): Scales, computes absolute values and converts the result to 8-bit.

ConvexHull(InputArray, OutputArray, bool, bool): Computes convex hull for a set of 2D points.

ConvexHull(IEnumerable<Point2f>, bool): Computes convex hull for a set of 2D points.

ConvexHull(IEnumerable<Point>, bool): Computes convex hull for a set of 2D points.

ConvexHullIndices(IEnumerable<Point2f>, bool): Computes convex hull for a set of 2D points.

ConvexHullIndices(IEnumerable<Point>, bool): Computes convex hull for a set of 2D points.

ConvexityDefects(InputArray, InputArray, OutputArray): Computes the contour convexity defects

ConvexityDefects(IEnumerable<Point2f>, IEnumerable<int>): Computes the contour convexity defects

ConvexityDefects(IEnumerable<Point>, IEnumerable<int>): Computes the contour convexity defects

CopyMakeBorder(InputArray, OutputArray, int, int, int, int, BorderTypes, Scalar?): Forms a border around the image

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

CornerEigenValsAndVecs(InputArray, OutputArray, int, int, BorderTypes): computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.

CornerHarris(InputArray, OutputArray, int, int, double, BorderTypes): Harris corner detector.

CornerMinEigenVal(InputArray, OutputArray, int, int, BorderTypes): Calculates the minimal eigenvalue of gradient matrices for corner detection.

CornerSubPix(InputArray, IEnumerable<Point2f>, Size, Size, TermCriteria): adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria

CorrectMatches(InputArray, InputArray, InputArray, OutputArray, OutputArray): Refines coordinates of corresponding points.

CorrectMatches(double[,], IEnumerable<Point2d>, IEnumerable<Point2d>, out Point2d[], out Point2d[]): Refines coordinates of corresponding points.

CountNonZero(InputArray): computes the number of nonzero array elements

CreateAffineTransformer(bool): Creates an Affine shape transformer.

CreateCLAHE(double, Size?): Creates a predefined CLAHE object

CreateChiHistogramCostExtractor(int, float): Creates a chi-squared histogram cost extractor.

CreateEMDHistogramCostExtractor(DistanceTypes, int, float): Creates an EMD-based histogram cost extractor.

CreateEMDL1HistogramCostExtractor(int, float): Creates an EMD-L1 histogram cost extractor.

CreateFrameSource_Camera(int)

CreateFrameSource_Empty()

CreateFrameSource_Video(string)

CreateFrameSource_Video_CUDA(string)

CreateHanningWindow(OutputArray, Size, MatType): Computes a Hanning window coefficients in two dimensions.

CreateNormHistogramCostExtractor(DistanceTypes, int, float): Creates a norm-based histogram cost extractor.

CreateOptFlow_Brox_GPU()

CreateOptFlow_DualTVL1_GPU()

CreateOptFlow_Farneback()

CreateOptFlow_Farneback_GPU()

CreateOptFlow_PyrLK_GPU()

CreateSuperResolution_BTVL1(): Create Bilateral TV-L1 Super Resolution.

CreateSuperResolution_BTVL1_CUDA(): Create Bilateral TV-L1 Super Resolution.

CreateThinPlateSplineShapeTransformer(double): Creates a Thin Plate Spline shape transformer.

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

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

CubeRoot(float): computes cube root of the argument

CurrentUIFramework(): Returns the HighGUI backend name in use: could be COCOA, GTK2/3, QT, WAYLAND or WIN32. Returns an empty string if there is no available UI backend.

CvtColor(InputArray, OutputArray, ColorConversionCodes, int, AlgorithmHint): Converts image from one color space to another

CvtColorTwoPlane(InputArray, InputArray, OutputArray, ColorConversionCodes, AlgorithmHint): Converts an image from one color space to another where the source image is stored in two planes. This function only supports YUV420 to RGB conversion as of now.

Dct(InputArray, OutputArray, DctFlags): Performs forward or inverse 1D or 2D Discrete Cosine Transformation

Decolor(InputArray, OutputArray, OutputArray): 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 .

DecomposeEssentialMat(InputArray, OutputArray, OutputArray, OutputArray): Decomposes an essential matrix to possible rotations and translation.

DecomposeHomographyMat(InputArray, InputArray, out Mat[], out Mat[], out Mat[]): Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).

DecomposeProjectionMatrix(InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray): Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

DecomposeProjectionMatrix(double[,], out double[,], out double[,], out double[]): Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

DecomposeProjectionMatrix(double[,], out double[,], out double[,], out double[], out double[,], out double[,], out double[,], out double[]): Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

Demosaicing(InputArray, OutputArray, ColorConversionCodes, int): main function for all demosaicing processes

DenoiseTVL1(IEnumerable<Mat>, Mat, double, int): 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.

DepthTo3d(InputArray, InputArray, OutputArray, InputArray): Converts a depth image to 3d points.

DepthTo3dSparse(InputArray, InputArray, InputArray, OutputArray): Converts the specified sparse depth coordinates to 3d points.

DestroyAllWindows(): Destroys all of the HighGUI windows.

DestroyWindow(string): Destroys the specified window.

DetailEnhance(InputArray, OutputArray, float, float): This filter enhances the details of a particular image.

Determinant(InputArray): computes determinant of a square matrix

Dft(InputArray, OutputArray, DftFlags, int): Performs a forward Discrete Fourier transform of 1D or 2D floating-point array.

Dilate(InputArray, OutputArray, InputArray, Point?, int, BorderTypes, Scalar?): Dilates an image by using a specific structuring element.

DistanceTransform(InputArray, OutputArray, DistanceTypes, DistanceTransformMasks, int): computes the distance transform map

DistanceTransformWithLabels(InputArray, OutputArray, OutputArray, DistanceTypes, DistanceTransformMasks, DistanceTransformLabelTypes): Calculates the distance to the closest zero pixel for each pixel of the source image.

Divide(InputArray, InputArray, OutputArray, double, MatType?): Performs per-element division of two arrays or a scalar by an array.

Divide(double, InputArray, OutputArray, int): Performs per-element division of two arrays or a scalar by an array.

DrawChessboardCorners(InputOutputArray, Size, InputArray, bool): Renders the detected chessboard corners.

DrawChessboardCorners(InputOutputArray, Size, IEnumerable<Point2f>, bool): Renders the detected chessboard corners.

DrawContours(InputOutputArray, IEnumerable<Mat>, int, Scalar, int, LineTypes, InputArray, int, Point?): draws contours in the image

DrawContours(InputOutputArray, IEnumerable<IEnumerable<Point>>, int, Scalar, int, LineTypes, IEnumerable<HierarchyIndex>?, int, Point?): draws contours in the image

DrawFrameAxes(InputOutputArray, InputArray, InputArray, InputArray, InputArray, float, int): Draw axes of the world/object coordinate system from pose estimation.

DrawKeypoints(InputArray, IEnumerable<KeyPoint>, InputOutputArray, Scalar?, DrawMatchesFlags): Draw keypoints.

DrawMarker(InputOutputArray, Point, Scalar, MarkerTypes, int, int, LineTypes)

Draws a marker on a predefined position in an image.

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

DrawMatches(Mat, IEnumerable<KeyPoint>, Mat, IEnumerable<KeyPoint>, IEnumerable<DMatch>, Mat, Scalar?, Scalar?, IEnumerable<byte>?, DrawMatchesFlags): Draws the found matches of keypoints from two images.

DrawMatchesKnn(Mat, IEnumerable<KeyPoint>, Mat, IEnumerable<KeyPoint>, IEnumerable<IEnumerable<DMatch>>, Mat, Scalar?, Scalar?, IEnumerable<IEnumerable<byte>>?, DrawMatchesFlags): Draws the found matches of keypoints from two images.

EMD(InputArray, InputArray, DistanceTypes)

Computes the "minimal work" distance between two weighted point configurations.

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

EMD(InputArray, InputArray, DistanceTypes, InputArray)

Computes the "minimal work" distance between two weighted point configurations.

EMD(InputArray, InputArray, DistanceTypes, InputArray, out float, OutputArray)

Computes the "minimal work" distance between two weighted point configurations.

EMDL1(InputArray, InputArray): Computes the Earth Mover's Distance L1 (EMDL1) between two weighted point configurations.

EdgePreservingFilter(InputArray, OutputArray, EdgePreservingMethods, float, float): Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications @cite EM11 .

Eigen(InputArray, OutputArray, OutputArray): Computes eigenvalues and eigenvectors of a symmetric matrix.

EigenNonSymmetric(InputArray, OutputArray, OutputArray): Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).

Ellipse(InputOutputArray, Point, Size, double, double, double, Scalar, int, LineTypes, int): Draws simple or thick elliptic arc or fills ellipse sector

Ellipse(InputOutputArray, RotatedRect, Scalar, int, LineTypes): Draws simple or thick elliptic arc or fills ellipse sector

Ellipse2Poly(Point, Size, int, int, int, int): 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.

Ellipse2Poly(Point2d, Size2d, int, int, int, int): 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, OutputArray): normalizes the grayscale image brightness and contrast by normalizing its histogram

Erode(InputArray, OutputArray, InputArray, Point?, int, BorderTypes, Scalar?): Erodes an image by using a specific structuring element.

EstimateAffine2D(InputArray, InputArray, OutputArray, RobustEstimationAlgorithms, double, ulong, double, ulong): Computes an optimal affine transformation between two 2D point sets.

EstimateAffine3D(InputArray, InputArray, OutputArray, OutputArray, double, double): Computes an optimal affine transformation between two 3D point sets.

EstimateAffinePartial2D(InputArray, InputArray, OutputArray, RobustEstimationAlgorithms, double, ulong, double, ulong): Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

EstimateChessboardSharpness(InputArray, Size, InputArray, float, bool, OutputArray): Estimates the sharpness of a detected chessboard. Image sharpness, as well as brightness, are a critical parameter for accuracy of feature point extraction. As an example, consider the sharpness level of a camera as being described in terms of a Gaussian low pass filter and estimate the parameter based on the width of the transition area between a fully saturated pixel and the background pixel.

EstimateTranslation2D(InputArray, InputArray, OutputArray, RobustEstimationAlgorithms, double, ulong, double, ulong): Computes an optimal translation between two 2D point sets.

EstimateTranslation3D(InputArray, InputArray, OutputArray, OutputArray, double, double): Computes an optimal translation between two 3D point sets using RANSAC.

EvaluateFeatureDetector(Mat, Mat, Mat, ref KeyPoint[], ref KeyPoint[], out float, out int)

Exp(InputArray, OutputArray): computes exponent of each matrix element (dst = e**src)

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

FAST(InputArray, int, bool): Detects corners using the FAST algorithm

FAST(InputArray, int, bool, FASTType): Detects corners using the FAST algorithm

FarthestPointSampling(OutputArray, InputArray, int, float): Point cloud sampling by Farthest Point Sampling (FPS).

FarthestPointSampling(OutputArray, InputArray, float, float): Point cloud sampling by Farthest Point Sampling (FPS).

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

FastNlMeansDenoising(InputArray, OutputArray, float, int, int): Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations. Noise expected to be a gaussian white noise

FastNlMeansDenoisingColored(InputArray, OutputArray, float, float, int, int): Modification of fastNlMeansDenoising function for colored images

FastNlMeansDenoisingColoredMulti(IEnumerable<Mat>, OutputArray, int, int, float, float, int, int): Modification of fastNlMeansDenoisingMulti function for colored images sequences

FastNlMeansDenoisingMulti(IEnumerable<Mat>, OutputArray, int, int, float, int, int): 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(InputOutputArray, InputArray, Scalar, LineTypes, int): Fills a convex polygon.

FillConvexPoly(Mat, IEnumerable<Point>, Scalar, LineTypes, int): Fills a convex polygon.

FillPoly(InputOutputArray, InputArray, Scalar, LineTypes, int, Point?): Fills the area bounded by one or more polygons

FillPoly(Mat, IEnumerable<IEnumerable<Point>>, Scalar, LineTypes, int, Point?): Fills the area bounded by one or more polygons

Filter2D(InputArray, OutputArray, InputArray, Filter2DParams?): Convolves an image with the kernel (OpenCV 5 parameter-struct overload).

Filter2D(InputArray, OutputArray, MatType, InputArray, Point?, double, BorderTypes): Convolves an image with the kernel

FilterHomographyDecompByVisibleRefpoints(IEnumerable<Mat>, IEnumerable<Mat>, InputArray, InputArray, OutputArray, InputArray): Filters homography decompositions based on additional information.

FilterSpeckles(InputOutputArray, double, int, double, InputOutputArray): filters off speckles (small regions of incorrectly computed disparity)

Find4QuadCornerSubpix(InputArray, InputOutputArray, Size): finds subpixel-accurate positions of the chessboard corners

Find4QuadCornerSubpix(InputArray, Point2f[], Size): finds subpixel-accurate positions of the chessboard corners

FindChessboardCorners(InputArray, Size, OutputArray, ChessboardFlags): Finds the positions of internal corners of the chessboard.

FindChessboardCorners(InputArray, Size, out Point2f[], ChessboardFlags): Finds the positions of internal corners of the chessboard.

FindChessboardCornersSB(InputArray, Size, OutputArray, ChessboardFlags): Finds the positions of internal corners of the chessboard using a sector based approach.

FindChessboardCornersSB(InputArray, Size, out Point2f[], ChessboardFlags): Finds the positions of internal corners of the chessboard using a sector based approach.

FindCirclesGrid(InputArray, Size, OutputArray, FindCirclesGridFlags, Feature2D?): Finds centers in the grid of circles.

FindCirclesGrid(InputArray, Size, OutputArray, FindCirclesGridFlags, Feature2D?, in CirclesGridFinderParameters): Finds centers in the grid of circles, using custom finder parameters.

FindCirclesGrid(InputArray, Size, out Point2f[], FindCirclesGridFlags, Feature2D?): Finds centers in the grid of circles.

FindCirclesGrid(InputArray, Size, out Point2f[], FindCirclesGridFlags, Feature2D?, in CirclesGridFinderParameters): Finds centers in the grid of circles, using custom finder parameters.

FindContours(InputArray, out Mat[], OutputArray, RetrievalModes, ContourApproximationModes, Point?): Finds contours in a binary image.

FindContours(InputArray, out Point[][], out HierarchyIndex[], RetrievalModes, ContourApproximationModes, Point?): Finds contours in a binary image.

FindContoursAsArray(InputArray, RetrievalModes, ContourApproximationModes, Point?): Finds contours in a binary image.

FindContoursAsMat(InputArray, RetrievalModes, ContourApproximationModes, Point?): Finds contours in a binary image.

FindContoursLinkRuns(InputArray, out Point[][]): Finds contours in a binary image using the link-runs algorithm (OpenCV 5), without hierarchy output.

FindContoursLinkRuns(InputArray, out Point[][], out HierarchyIndex[]): Finds contours in a binary image using the link-runs algorithm (OpenCV 5). This is an alternative to FindContours(InputArray, out Point[][], out HierarchyIndex[], RetrievalModes, ContourApproximationModes, Point?) with reduced memory consumption; it always uses the equivalent of RETR_CCOMP retrieval.

FindEssentialMat(InputArray, InputArray, InputArray, EssentialMatMethod, double, double, OutputArray): Calculates an essential matrix from the corresponding points in two images.

FindEssentialMat(InputArray, InputArray, double, Point2d, EssentialMatMethod, double, double, OutputArray): Calculates an essential matrix from the corresponding points in two images.

FindFundamentalMat(InputArray, InputArray, FundamentalMatMethods, double, double, OutputArray): Calculates a fundamental matrix from the corresponding points in two images.

FindFundamentalMat(InputArray, InputArray, OutputArray, UsacParams?): Calculates a fundamental matrix from the corresponding points in two images, using the USAC robust estimation framework (OpenCV 5).

FindFundamentalMat(IEnumerable<Point2d>, IEnumerable<Point2d>, FundamentalMatMethods, double, double, OutputArray): Calculates a fundamental matrix from the corresponding points in two images.

FindFundamentalMat(IEnumerable<Point2f>, IEnumerable<Point2f>, FundamentalMatMethods, double, double, OutputArray): Calculates a fundamental matrix from the corresponding points in two images.

FindHomography(InputArray, InputArray, HomographyMethods, double, OutputArray, int, double): computes the best-fit perspective transformation mapping srcPoints to dstPoints.

FindHomography(InputArray, InputArray, OutputArray, UsacParams?): computes the best-fit perspective transformation mapping srcPoints to dstPoints.

FindHomography(IEnumerable<Point2d>, IEnumerable<Point2d>, HomographyMethods, double, OutputArray, int, double): computes the best-fit perspective transformation mapping srcPoints to dstPoints.

FindNonZero(InputArray, OutputArray): returns the list of locations of non-zero pixels

FindPlanes(InputArray, InputArray, OutputArray, OutputArray, int, int, double, double, double, double, RgbdPlaneMethod): Finds the planes in a depth image.

FindTransformECC(InputArray, InputArray, InputOutputArray, MotionTypes, TermCriteria, InputArray, int): Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08 .

FindTransformECC(InputArray, InputArray, InputOutputArray, MotionTypes, TermCriteria?, InputArray): Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08 .

FindTransformECCMultiScale(InputArray, InputArray, InputOutputArray, ECCParameters?, InputArray, InputArray): Finds the geometric transform (warp) between two images in terms of the ECC criterion. Uses pyramids, making the function more stable and able to correctly handle more sophisticated cases than FindTransformECC(InputArray, InputArray, InputOutputArray, MotionTypes, TermCriteria?, InputArray).

FindTransformECCWithMask(InputArray, InputArray, InputArray, InputArray, InputOutputArray, MotionTypes, TermCriteria?, int): Finds the geometric transform (warp) between two images in terms of the ECC criterion, using validity masks for both the template and the input images. This extends FindTransformECC(InputArray, InputArray, InputOutputArray, MotionTypes, TermCriteria?, InputArray) by adding a mask for the template image. The Enhanced Correlation Coefficient is evaluated only over pixels that are valid in both images: on each iteration inputMask is warped into the template frame and combined with templateMask, and only the intersection of these masks contributes to the objective function.

FiniteMask(InputArray, OutputArray): Computes a mask of finite (non-NaN, non-Inf) elements, a companion to PatchNaNs(InputOutputArray, double).

FitEllipse(InputArray): Fits ellipse to the set of 2D points.

FitEllipse(IEnumerable<Point2f>): Fits ellipse to the set of 2D points.

FitEllipse(IEnumerable<Point>): Fits ellipse to the set of 2D points.

FitEllipseAMS(InputArray)