Class CvInvoke

Namespace: Emgu.CV

Assembly: Emgu.CV.dll

Class that provide access to native OpenCV functions

public static class CvInvoke

Inheritance: object

CvInvoke

Inherited Members: object.GetType()

object.MemberwiseClone()

object.ToString()

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

Fields

BoolMarshalType

Represent a bool value in C++

public const UnmanagedType BoolMarshalType = U1

Field Value

UnmanagedType

BoolToIntMarshalType

Represent a int value in C++

public const UnmanagedType BoolToIntMarshalType = Bool

Field Value

UnmanagedType

CvCallingConvention

Opencv's calling convention

public const CallingConvention CvCallingConvention = Cdecl

Field Value

CallingConvention

CvErrorHandlerIgnoreError

An error handler which will ignore any error and continue

public static readonly CvInvoke.CvErrorCallback CvErrorHandlerIgnoreError

Field Value

CvInvoke.CvErrorCallback

CvErrorHandlerThrowException

The default Exception callback to handle Error thrown by OpenCV

public static readonly CvInvoke.CvErrorCallback CvErrorHandlerThrowException

Field Value

CvInvoke.CvErrorCallback

ExternCudaLibrary

The file name of the cvextern library

public const string ExternCudaLibrary = "cvextern"

Field Value

string

ExternLibrary

The file name of the cvextern library

public const string ExternLibrary = "cvextern"

Field Value

string

MorphologyDefaultBorderValue

The default morphology value.

public static MCvScalar MorphologyDefaultBorderValue

Field Value

MCvScalar

OpenCVModuleList

The List of the opencv modules

public static List<string> OpenCVModuleList

Field Value

List<string>

OpencvFFMpegLibrary

The file name of the opencv_ffmpeg library

public const string OpencvFFMpegLibrary = ""

Field Value

string

StringMarshalType

string marshaling type

public const UnmanagedType StringMarshalType = LPStr

Field Value

UnmanagedType

Properties

AvailableParallelBackends

Get a list of the available parallel backends.

public static string[] AvailableParallelBackends { get; }

Property Value

string[]

Backends

Returns list of all built-in backends

public static Backend[] Backends { get; }

Property Value

Backend[]

BuildInformation

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

public static string BuildInformation { get; }

Property Value

string

CameraBackends

Returns list of available backends which works via cv::VideoCapture(int index)

public static Backend[] CameraBackends { get; }

Property Value

Backend[]

ConfigDict

Get the dictionary that hold the Open CV build flags. The key is a String and the value is type double. If it is a flag, 0 means false and 1 means true

public static Dictionary<string, double> ConfigDict { get; }

Property Value

Dictionary<string, double>

HaveOpenCL

Check if we have OpenCL

public static bool HaveOpenCL { get; }

Property Value

bool

HaveOpenCLCompatibleGpuDevice

Gets a value indicating whether this device have open CL compatible gpu device.

public static bool HaveOpenCLCompatibleGpuDevice { get; }

Property Value

bool: true if have open CL compatible gpu device; otherwise, false.

HaveOpenVX

Check if use of OpenVX is possible.

public static bool HaveOpenVX { get; }

Property Value

bool: True use of OpenVX is possible.

LogLevel

Get or Set the log level.

public static LogLevel LogLevel { get; set; }

Property Value

LogLevel

NumThreads

Get or set the number of threads that are used by parallelized OpenCV functions

public static int NumThreads { get; set; }

Property Value

int

Remarks

When the argument is zero or negative, and at the beginning of the program, the number of threads is set to the number of processors in the system, as returned by the function omp_get_num_procs() from OpenMP runtime.

NumberOfCPUs

Returns the number of logical CPUs available for the process.

public static int NumberOfCPUs { get; }

Property Value

int

StreamBackends

Returns list of available backends which works via cv::VideoCapture(filename)

public static Backend[] StreamBackends { get; }

Property Value

Backend[]

ThreadNum

Returns the index, from 0 to cvGetNumThreads()-1, of the thread that called the function. It is a wrapper for the function omp_get_thread_num() from OpenMP runtime. The retrieved index may be used to access local-thread data inside the parallelized code fragments.

public static int ThreadNum { get; }

Property Value

int

UseOpenCL

Get or set if OpenCL should be used

public static bool UseOpenCL { get; set; }

Property Value

bool

UseOpenVX

Enable/disable use of OpenVX

public static bool UseOpenVX { get; set; }

Property Value

bool

UseOptimized

Enables or disables the optimized code.

public static bool UseOptimized { get; set; }

Property Value

bool: true if [use optimized]; otherwise, false.

Remarks

The function can be used to dynamically turn on and off optimized code (code that uses SSE2, AVX, and other instructions on the platforms that support it). It sets a global flag that is further checked by OpenCV functions. Since the flag is not checked in the inner OpenCV loops, it is only safe to call the function on the very top level in your application where you can be sure that no other OpenCV function is currently executed.

WriterBackends

Returns list of available backends which works via cv::VideoWriter()

public static Backend[] WriterBackends { get; }

Property Value

Backend[]

Methods

AbsDiff(IInputArray, IInputArray, IOutputArray)

Calculates absolute difference between two arrays. dst(I)c = abs(src1(I)c - src2(I)c). All the arrays must have the same data type and the same size (or ROI size)

public static void AbsDiff(IInputArray src1, IInputArray src2, IOutputArray dst)

Parameters

src1 IInputArray: The first source array
src2 IInputArray: The second source array
dst IOutputArray: The destination array

Accumulate(IInputArray, IInputOutputArray, IInputArray)

Adds the whole image or its selected region to accumulator sum

public static void Accumulate(IInputArray src, IInputOutputArray dst, IInputArray mask = null)

Parameters

src IInputArray: Input image, 1- or 3-channel, 8-bit or 32-bit floating point. (each channel of multi-channel image is processed independently).
dst IInputOutputArray: Accumulator of the same number of channels as input image, 32-bit or 64-bit floating-point.
mask IInputArray: Optional operation mask

AccumulateProduct(IInputArray, IInputArray, IInputOutputArray, IInputArray)

Adds product of 2 images or thier selected regions to accumulator acc

public static void AccumulateProduct(IInputArray src1, IInputArray src2, IInputOutputArray dst, IInputArray mask = null)

Parameters

src1 IInputArray: First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)
src2 IInputArray: Second input image, the same format as the first one
dst IInputOutputArray: Accumulator of the same number of channels as input images, 32-bit or 64-bit floating-point
mask IInputArray: Optional operation mask

AccumulateSquare(IInputArray, IInputOutputArray, IInputArray)

Adds the input src or its selected region, raised to power 2, to the accumulator sqsum

public static void AccumulateSquare(IInputArray src, IInputOutputArray dst, IInputArray mask = null)

Parameters

src IInputArray: Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently)
dst IInputOutputArray: Accumulator of the same number of channels as input image, 32-bit or 64-bit floating-point
mask IInputArray: Optional operation mask

AccumulateWeighted(IInputArray, IInputOutputArray, double, IInputArray)

Calculates weighted sum of input src and the accumulator acc so that acc becomes a running average of frame sequence: acc(x,y)=(1-alpha) * acc(x,y) + alpha * image(x,y) if mask(x,y)!=0 where alpha regulates update speed (how fast accumulator forgets about previous frames).

public static void AccumulateWeighted(IInputArray src, IInputOutputArray dst, double alpha, IInputArray mask = null)

Parameters

src IInputArray: Input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently).
dst IInputOutputArray: Accumulator of the same number of channels as input image, 32-bit or 64-bit floating-point.
alpha double: Weight of input image
mask IInputArray: Optional operation mask

AdaptiveThreshold(IInputArray, IOutputArray, double, AdaptiveThresholdType, ThresholdType, int, double)

Transforms grayscale image to binary image. Threshold calculated individually for each pixel. For the method CV_ADAPTIVE_THRESH_MEAN_C it is a mean of blockSize x blockSize pixel neighborhood, subtracted by param1. For the method CV_ADAPTIVE_THRESH_GAUSSIAN_C it is a weighted sum (gaussian) of blockSize x blockSize pixel neighborhood, subtracted by param1.

public static void AdaptiveThreshold(IInputArray src, IOutputArray dst, double maxValue, AdaptiveThresholdType adaptiveType, ThresholdType thresholdType, int blockSize, double param1)

Parameters

src IInputArray: Source array (single-channel, 8-bit of 32-bit floating point).
dst IOutputArray: Destination array; must be either the same type as src or 8-bit.
maxValue double: Maximum value to use with CV_THRESH_BINARY and CV_THRESH_BINARY_INV thresholding types
adaptiveType AdaptiveThresholdType: Adaptive_method
thresholdType ThresholdType: Thresholding type. must be one of CV_THRESH_BINARY, CV_THRESH_BINARY_INV
blockSize int: The size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, ...
param1 double: Constant subtracted from mean or weighted mean. It may be negative.

Add(IInputArray, IInputArray, IOutputArray, IInputArray, DepthType)

Adds one array to another one: dst(I)=src1(I)+src2(I) if mask(I)!=0All the arrays must have the same type, except the mask, and the same size (or ROI size)

public static void Add(IInputArray src1, IInputArray src2, IOutputArray dst, IInputArray mask = null, DepthType dtype = DepthType.Default)

Parameters

src1 IInputArray: The first source array.
src2 IInputArray: The second source array.
dst IOutputArray: The destination array.
mask IInputArray: Operation mask, 8-bit single channel array; specifies elements of destination array to be changed.
dtype DepthType: Optional depth type of the output array

AddWeighted(IInputArray, double, IInputArray, double, double, IOutputArray, DepthType)

Calculated weighted sum of two arrays as following: dst(I)=src1(I)*alpha+src2(I)*beta+gamma All the arrays must have the same type and the same size (or ROI size)

public static void AddWeighted(IInputArray src1, double alpha, IInputArray src2, double beta, double gamma, IOutputArray dst, DepthType dtype = DepthType.Default)

Parameters

src1 IInputArray: The first source array.
alpha double: Weight of the first array elements.
src2 IInputArray: The second source array.
beta double: Weight of the second array elements.
gamma double: Scalar, added to each sum.
dst IOutputArray: The destination array.
dtype DepthType: Optional depth of the output array; when both input arrays have the same depth

ApplyColorMap(IInputArray, IOutputArray, ColorMapType)

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

public static void ApplyColorMap(IInputArray src, IOutputArray dst, ColorMapType colorMapType)

Parameters

src IInputArray: The source image, grayscale or colored of type CV_8UC1 or CV_8UC3
dst IOutputArray: The result is the colormapped source image
colorMapType ColorMapType: The type of color map

ApplyColorMap(IInputArray, IOutputArray, IInputArray)

Applies a user colormap on a given image.

public static void ApplyColorMap(IInputArray src, IOutputArray dst, IInputArray userColorMap)

Parameters

src IInputArray: The source image, grayscale or colored of type CV_8UC1 or CV_8UC3.
dst IOutputArray: The result is the colormapped source image.
userColorMap IInputArray: The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256

ApproxPolyDP(IInputArray, IOutputArray, double, bool)

Approximates a polygonal curve(s) with the specified precision.

public static void ApproxPolyDP(IInputArray curve, IOutputArray approxCurve, double epsilon, bool closed)

Parameters

curve IInputArray: Input vector of a 2D point
approxCurve IOutputArray: Result of the approximation. The type should match the type of the input curve.
epsilon double: Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.
closed bool: If true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

ArcLength(IInputArray, bool)

Calculates a contour perimeter or a curve length

public static double ArcLength(IInputArray curve, bool isClosed)

Parameters

curve IInputArray: Sequence or array of the curve points
isClosed bool: Indicates whether the curve is closed or not.

Returns

double: Contour perimeter or a curve length

ArrowedLine(IInputOutputArray, Point, Point, MCvScalar, int, LineType, int, double)

Draws a arrow segment pointing from the first point to the second one.

public static void ArrowedLine(IInputOutputArray img, Point pt1, Point pt2, MCvScalar color, int thickness = 1, LineType lineType = LineType.EightConnected, int shift = 0, double tipLength = 0.1)

Parameters

img IInputOutputArray: Image
pt1 Point: The point the arrow starts from.
pt2 Point: The point the arrow points to.
color MCvScalar: Line color.
thickness int: Line thickness.
lineType LineType: Type of the line.
shift int: Number of fractional bits in the point coordinates.
tipLength double: The length of the arrow tip in relation to the arrow length

BilateralFilter(IInputArray, IOutputArray, int, double, double, BorderType)

Applies the bilateral filter to an image.

public static void BilateralFilter(IInputArray src, IOutputArray dst, int d, double sigmaColor, double sigmaSpace, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: Source 8-bit or floating-point, 1-channel or 3-channel image.
dst IOutputArray: Destination image of the same size and type as src .
d int: Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace .
sigmaColor double: Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpace double: Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0 , it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.
borderType BorderType: Border mode used to extrapolate pixels outside of the image.

BitwiseAnd(IInputArray, IInputArray, IOutputArray, IInputArray)

Calculates per-element bit-wise logical conjunction of two arrays: dst(I)=src1(I) & src2(I) if mask(I)!=0 In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size

public static void BitwiseAnd(IInputArray src1, IInputArray src2, IOutputArray dst, IInputArray mask = null)

Parameters

src1 IInputArray: The first source array
src2 IInputArray: The second source array
dst IOutputArray: The destination array
mask IInputArray: Operation mask, 8-bit single channel array; specifies elements of destination array to be changed

BitwiseNot(IInputArray, IOutputArray, IInputArray)

Inverses every bit of every array element:

public static void BitwiseNot(IInputArray src, IOutputArray dst, IInputArray mask = null)

Parameters

src IInputArray: The source array
dst IOutputArray: The destination array
mask IInputArray: The optional mask for the operation, use null to ignore

BitwiseOr(IInputArray, IInputArray, IOutputArray, IInputArray)

Calculates per-element bit-wise disjunction of two arrays: dst(I)=src1(I)|src2(I) In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size

public static void BitwiseOr(IInputArray src1, IInputArray src2, IOutputArray dst, IInputArray mask = null)

Parameters

src1 IInputArray: The first source array
src2 IInputArray: The second source array
dst IOutputArray: The destination array
mask IInputArray: Operation mask, 8-bit single channel array; specifies elements of destination array to be changed

BitwiseXor(IInputArray, IInputArray, IOutputArray, IInputArray)

Calculates per-element bit-wise logical conjunction of two arrays: dst(I)=src1(I)^src2(I) if mask(I)!=0 In the case of floating-point arrays their bit representations are used for the operation. All the arrays must have the same type, except the mask, and the same size

public static void BitwiseXor(IInputArray src1, IInputArray src2, IOutputArray dst, IInputArray mask = null)

Parameters

src1 IInputArray: The first source array
src2 IInputArray: The second source array
dst IOutputArray: The destination array
mask IInputArray: Mask, 8-bit single channel array; specifies elements of destination array to be changed.

BlendLinear(IInputArray, IInputArray, IInputArray, IInputArray, IOutputArray)

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

public static void BlendLinear(IInputArray src1, IInputArray src2, IInputArray weights1, IInputArray weights2, IOutputArray dst)

Parameters

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

Blur(IInputArray, IOutputArray, Size, Point, BorderType)

Blurs an image using the normalized box filter.

public static void Blur(IInputArray src, IOutputArray dst, Size ksize, Point anchor, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: input image; it 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 IOutputArray: Output image of the same size and type as src.
ksize Size: Blurring kernel size.
anchor Point: Anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderType BorderType: Border mode used to extrapolate pixels outside of the image.

BoundingRectangle(IInputArray)

Returns the up-right bounding rectangle for 2d point set

public static Rectangle BoundingRectangle(IInputArray points)

Parameters

points IInputArray: Input 2D point set, stored in std::vector or Mat.

Returns

Rectangle: The up-right bounding rectangle for 2d point set

BoundingRectangle(Point[])

Returns the up-right bounding rectangle for 2d point set

public static Rectangle BoundingRectangle(Point[] points)

Parameters

points Point[]: Input 2D point set

Returns

Rectangle: The up-right bounding rectangle for 2d point set

BoxFilter(IInputArray, IOutputArray, DepthType, Size, Point, bool, BorderType)

Blurs an image using the box filter.

public static void BoxFilter(IInputArray src, IOutputArray dst, DepthType ddepth, Size ksize, Point anchor, bool normalize = true, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: Input image.
dst IOutputArray: Output image of the same size and type as src.
ddepth DepthType: The output image depth (-1 to use src.depth()).
ksize Size: Blurring kernel size.
anchor Point: Anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalize bool: Specifying whether the kernel is normalized by its area or not.
borderType BorderType: Border mode used to extrapolate pixels outside of the image.

BoxPoints(RotatedRect)

Calculates vertices of the input 2d box.

public static PointF[] BoxPoints(RotatedRect box)

Parameters

box RotatedRect: The box

Returns

PointF[]: The four vertices of rectangles.

BoxPoints(RotatedRect, IOutputArray)

Calculates vertices of the input 2d box.

public static void BoxPoints(RotatedRect box, IOutputArray points)

Parameters

box RotatedRect: The box
points IOutputArray: The output array of four vertices of rectangles.

Broadcast(IInputArray, IInputArray, IOutputArray)

Broadcast the given Mat to the given shape.

public static void Broadcast(IInputArray src, IInputArray shape, IOutputArray dst)

Parameters

src IInputArray: Input array
shape IInputArray: Target shape. Should be a list of CV_32S numbers. Note that negative values are not supported.
dst IOutputArray: Output array that has the given shape

BuildOpticalFlowPyramid(IInputArray, IOutputArrayOfArrays, Size, int, bool, BorderType, BorderType, bool)

Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.

public static int BuildOpticalFlowPyramid(IInputArray img, IOutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderType pyrBorder = BorderType.Default, BorderType derivBorder = BorderType.Constant, bool tryReuseInputImage = true)

Parameters

img IInputArray: 8-bit input image.
pyramid IOutputArrayOfArrays: 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 BorderType: The border mode for pyramid layers.
derivBorder BorderType: 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.

Returns

int: Number of levels in constructed pyramid. Can be less than maxLevel.

BuildPyramid(IInputArray, IOutputArrayOfArrays, int, BorderType)

The function constructs a vector of images and builds the Gaussian pyramid by recursively applying pyrDown to the previously built pyramid layers, starting from dst[0]==src.

public static void BuildPyramid(IInputArray src, IOutputArrayOfArrays dst, int maxlevel, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: Source image. Check pyrDown for the list of supported types.
dst IOutputArrayOfArrays: Destination vector of maxlevel+1 images of the same type as src. dst[0] will be the same as src. dst[1] is the next pyramid layer, a smoothed and down-sized src, and so on.
maxlevel int: 0-based index of the last (the smallest) pyramid layer. It must be non-negative.
borderType BorderType: Pixel extrapolation method

CLAHE(IInputArray, double, Size, IOutputArray)

Contrast Limited Adaptive Histogram Equalization (CLAHE)

public static void CLAHE(IInputArray src, double clipLimit, Size tileGridSize, IOutputArray dst)

Parameters

src IInputArray: The source image
clipLimit double: Clip Limit, use 40 for default
tileGridSize Size: Tile grid size, use (8, 8) for default
dst IOutputArray: The destination image

CalcBackProject(IInputArrayOfArrays, int[], IInputArray, IOutputArray, float[], double)

Calculates the back projection of a histogram.

public static void CalcBackProject(IInputArrayOfArrays images, int[] channels, IInputArray hist, IOutputArray backProject, float[] ranges, double scale = 1)

Parameters

images IInputArrayOfArrays: Source arrays. They all should have the same depth, CV_8U or CV_32F , and the same size. Each of them can have an arbitrary number of channels.
channels int[]: Number of source images.
hist IInputArray: Input histogram that can be dense or sparse.
backProject IOutputArray: Destination back projection array that is a single-channel array of the same size and depth as images[0] .
ranges float[]: Array of arrays of the histogram bin boundaries in each dimension.
scale double: Optional scale factor for the output back projection.

CalcCovarMatrix(IInputArray, IOutputArray, IInputOutputArray, CovarMethod, DepthType)

Calculates the covariance matrix of a set of vectors.

public static void CalcCovarMatrix(IInputArray samples, IOutputArray covar, IInputOutputArray mean, CovarMethod flags, DepthType ctype = DepthType.Cv64F)

Parameters

samples IInputArray: Samples stored either as separate matrices or as rows/columns of a single matrix.
covar IOutputArray: Output covariance matrix of the type ctype and square size.
mean IInputOutputArray: Input or output (depending on the flags) array as the average value of the input vectors.
flags CovarMethod: Operation flags
ctype DepthType: Type of the matrix

CalcGlobalOrientation(IInputArray, IInputArray, IInputArray, double, double)

Calculates the general motion direction in the selected region and returns the angle between 0 and 360. At first the function builds the orientation histogram and finds the basic orientation as a coordinate of the histogram maximum. After that the function calculates the shift relative to the basic orientation as a weighted sum of all orientation vectors: the more recent is the motion, the greater is the weight. The resultant angle is a circular sum of the basic orientation and the shift.

public static double CalcGlobalOrientation(IInputArray orientation, IInputArray mask, IInputArray mhi, double timestamp, double duration)

Parameters

orientation IInputArray: Motion gradient orientation image; calculated by the function cvCalcMotionGradient.
mask IInputArray: Mask image. It may be a conjunction of valid gradient mask, obtained with cvCalcMotionGradient and mask of the region, whose direction needs to be calculated.
mhi IInputArray: Motion history image.
timestamp double: Current time in milliseconds or other units, it is better to store time passed to cvUpdateMotionHistory before and reuse it here, because running cvUpdateMotionHistory and cvCalcMotionGradient on large images may take some time.
duration double: Maximal duration of motion track in milliseconds, the same as in cvUpdateMotionHistory

Returns

double: The angle

CalcHist(IInputArrayOfArrays, int[], IInputArray, IOutputArray, int[], float[], bool)

Calculates a histogram of a set of arrays.

public static void CalcHist(IInputArrayOfArrays images, int[] channels, IInputArray mask, IOutputArray hist, int[] histSize, float[] ranges, bool accumulate)

Parameters

images IInputArrayOfArrays: Source arrays. They all should have the same depth, CV_8U, CV_16U or CV_32F , and the same size. Each of them can have an arbitrary number of channels.
channels int[]: List of the channels used to compute the histogram.
mask IInputArray: Optional mask. If the matrix is not empty, it must be an 8-bit array of the same size as images[i] . The non-zero mask elements mark the array elements counted in the histogram.
hist IOutputArray: Output histogram
histSize int[]: Array of histogram sizes in each dimension.
ranges float[]: Array of the dims arrays of the histogram bin boundaries in each dimension.
accumulate bool: Accumulation flag. If it is set, the histogram is not cleared in the beginning when it is allocated. This feature enables you to compute a single histogram from several sets of arrays, or to update the histogram in time.

CalcMotionGradient(IInputArray, IOutputArray, IOutputArray, double, double, int)

Calculates the derivatives Dx and Dy of mhi and then calculates gradient orientation as: orientation(x,y)=arctan(Dy(x,y)/Dx(x,y)) where both Dx(x,y)' and Dy(x,y)' signs are taken into account (as in cvCartToPolar function). After that mask is filled to indicate where the orientation is valid (see delta1 and delta2 description).

public static void CalcMotionGradient(IInputArray mhi, IOutputArray mask, IOutputArray orientation, double delta1, double delta2, int apertureSize = 3)

Parameters

mhi IInputArray: Motion history image
mask IOutputArray: Mask image; marks pixels where motion gradient data is correct. Output parameter.
orientation IOutputArray: Motion gradient orientation image; contains angles from 0 to ~360.
delta1 double: The function finds minimum (m(x,y)) and maximum (M(x,y)) mhi values over each pixel (x,y) neihborhood and assumes the gradient is valid only if min(delta1,delta2) <= M(x,y)-m(x,y) <= max(delta1,delta2).
delta2 double: The function finds minimum (m(x,y)) and maximum (M(x,y)) mhi values over each pixel (x,y) neihborhood and assumes the gradient is valid only if min(delta1,delta2) <= M(x,y)-m(x,y) <= max(delta1,delta2).
apertureSize int: Aperture size of derivative operators used by the function: CV_SCHARR, 1, 3, 5 or 7 (see cvSobel).

CalcOpticalFlowFarneback(IInputArray, IInputArray, IInputOutputArray, double, int, int, int, int, double, OpticalflowFarnebackFlag)

Computes dense optical flow using Gunnar Farneback's algorithm

public static void CalcOpticalFlowFarneback(IInputArray prev0, IInputArray next0, IInputOutputArray flow, double pyrScale, int levels, int winSize, int iterations, int polyN, double polySigma, OpticalflowFarnebackFlag flags)

Parameters

prev0 IInputArray: The first 8-bit single-channel input image
next0 IInputArray: The second input image of the same size and the same type as prevImg
flow IInputOutputArray: The computed flow image; will have the same size as prevImg and type CV 32FC2
pyrScale double: Specifies the image scale (!1) to build the pyramids for each image. pyrScale=0.5 means the classical pyramid, where each next layer is twice smaller than the previous
levels int: The 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: The averaging window size; The 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: The 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. The 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 that are used as a basis for the polynomial expansion. For poly n=5 you can set poly sigma=1.1, for poly n=7 a good value would be poly sigma=1.5
flags OpticalflowFarnebackFlag: The operation flags

CalcOpticalFlowFarneback(Image<Gray, byte>, Image<Gray, byte>, Image<Gray, float>, Image<Gray, float>, double, int, int, int, int, double, OpticalflowFarnebackFlag)

Computes dense optical flow using Gunnar Farneback's algorithm

public static void CalcOpticalFlowFarneback(Image<Gray, byte> prev0, Image<Gray, byte> next0, Image<Gray, float> flowX, Image<Gray, float> flowY, double pyrScale, int levels, int winSize, int iterations, int polyN, double polySigma, OpticalflowFarnebackFlag flags)

Parameters

prev0 Image<Gray, byte>: The first 8-bit single-channel input image
next0 Image<Gray, byte>: The second input image of the same size and the same type as prevImg
flowX Image<Gray, float>: The computed flow image for x-velocity; will have the same size as prevImg
flowY Image<Gray, float>: The computed flow image for y-velocity; will have the same size as prevImg
pyrScale double: Specifies the image scale (!1) to build the pyramids for each image. pyrScale=0.5 means the classical pyramid, where each next layer is twice smaller than the previous
levels int: The 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: The averaging window size; The 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: The 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. The 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 that are used as a basis for the polynomial expansion. For poly n=5 you can set poly sigma=1.1, for poly n=7 a good value would be poly sigma=1.5
flags OpticalflowFarnebackFlag: The operation flags

CalcOpticalFlowPyrLK(IInputArray, IInputArray, IInputArray, IInputOutputArray, IOutputArray, IOutputArray, Size, int, MCvTermCriteria, LKFlowFlag, double)

Implements sparse iterative version of Lucas-Kanade optical flow in pyramids ([Bouguet00]). It calculates coordinates of the feature points on the current video frame given their coordinates on the previous frame. The function finds the coordinates with sub-pixel accuracy.

public static void CalcOpticalFlowPyrLK(IInputArray prevImg, IInputArray nextImg, IInputArray prevPts, IInputOutputArray nextPts, IOutputArray status, IOutputArray err, Size winSize, int maxLevel, MCvTermCriteria criteria, LKFlowFlag flags = LKFlowFlag.Default, double minEigThreshold = 0.0001)

Parameters

prevImg IInputArray: First frame, at time t.
nextImg IInputArray: Second frame, at time t + dt .
prevPts IInputArray: Array of points for which the flow needs to be found.
nextPts IInputOutputArray: Array of 2D points containing calculated new positions of input
status IOutputArray: Array. Every element of the array is set to 1 if the flow for the corresponding feature has been found, 0 otherwise.
err IOutputArray: Array of double numbers containing difference between patches around the original and moved points. Optional parameter; can be NULL
winSize Size: Size of the search window of each pyramid level.
maxLevel int: Maximal pyramid level number. If 0 , pyramids are not used (single level), if 1 , two levels are used, etc.
criteria MCvTermCriteria: Specifies when the iteration process of finding the flow for each point on each pyramid level should be stopped.
flags LKFlowFlag: Miscellaneous flags
minEigThreshold double: the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations (this matrix is called a spatial gradient matrix in [Bouguet00]), divided by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding feature is filtered out and its flow is not processed, so it allows to remove bad points and get a performance boost.

Remarks

Both parameters prev_pyr and curr_pyr comply with the following rules: if the image pointer is 0, the function allocates the buffer internally, calculates the pyramid, and releases the buffer after processing. Otherwise, the function calculates the pyramid and stores it in the buffer unless the flag CV_LKFLOW_PYR_A[B]_READY is set. The image should be large enough to fit the Gaussian pyramid data. After the function call both pyramids are calculated and the readiness flag for the corresponding image can be set in the next call (i.e., typically, for all the image pairs except the very first one CV_LKFLOW_PYR_A_READY is set).

CalcOpticalFlowPyrLK(IInputArray, IInputArray, PointF[], Size, int, MCvTermCriteria, out PointF[], out byte[], out float[], LKFlowFlag, double)

Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in pyramids

public static void CalcOpticalFlowPyrLK(IInputArray prev, IInputArray curr, PointF[] prevFeatures, Size winSize, int level, MCvTermCriteria criteria, out PointF[] currFeatures, out byte[] status, out float[] trackError, LKFlowFlag flags = LKFlowFlag.Default, double minEigThreshold = 0.0001)

Parameters

prev IInputArray: First frame, at time t
curr IInputArray: Second frame, at time t + dt
prevFeatures PointF[]: Array of points for which the flow needs to be found
winSize Size: Size of the search window of each pyramid level
level int: Maximal pyramid level number. If 0 , pyramids are not used (single level), if 1 , two levels are used, etc
criteria MCvTermCriteria: Specifies when the iteration process of finding the flow for each point on each pyramid level should be stopped
currFeatures PointF[]: Array of 2D points containing calculated new positions of input features in the second image
status byte[]: Array. Every element of the array is set to 1 if the flow for the corresponding feature has been found, 0 otherwise
trackError float[]: Array of double numbers containing difference between patches around the original and moved points
flags LKFlowFlag: Flags
minEigThreshold double: the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations (this matrix is called a spatial gradient matrix in [Bouguet00]), divided by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding feature is filtered out and its flow is not processed, so it allows to remove bad points and get a performance boost.

CalibrateCamera(IInputArray, IInputArray, Size, IInputOutputArray, IInputOutputArray, IOutputArray, IOutputArray, CalibType, MCvTermCriteria)

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

public static double CalibrateCamera(IInputArray objectPoints, IInputArray imagePoints, Size imageSize, IInputOutputArray cameraMatrix, IInputOutputArray distortionCoeffs, IOutputArray rotationVectors, IOutputArray translationVectors, CalibType flags, MCvTermCriteria termCriteria)

Parameters

objectPoints IInputArray: 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 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. Although the points are 3D, they all lie in the calibration pattern's XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig. In the old interface all the vectors of object points from different views are concatenated together.
imagePoints IInputArray: In the new interface it is a vector of vectors of the projections of calibration pattern points. In the old interface all the vectors of object points from different views are concatenated together.
imageSize Size: Size of the image used only to initialize the camera intrinsic matrix.
cameraMatrix IInputOutputArray: Input/output 3x3 floating-point camera intrinsic matrix A [fx 0 cx; 0 fy cy; 0 0 1]. If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATION are specified, some or all of fx, fy, cx, cy must be initialized
distortionCoeffs IInputOutputArray: Input/output vector of distortion coefficients (k1,k2,p1,p2[,k3[,k4,k5,k6[,s1,s2,s3,s4[,τx,τy]]]]) of 4, 5, 8, 12 or 14 elements.
rotationVectors IOutputArray: Output vector of rotation vectors (Rodrigues) estimated for each pattern view. That is, each i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter description) brings the calibration pattern from the object coordinate space (in which object points are specified) to the camera coordinate space. In more technical terms, the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space to camera coordinate space. Due to its duality, this tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate space.
translationVectors IOutputArray: Output vector of translation vectors estimated for each pattern view, see parameter describtion above.
flags CalibType: Different flags
termCriteria MCvTermCriteria: The termination criteria

Returns

double: The final reprojection error

CalibrateCamera(MCvPoint3D32f[][], PointF[][], Size, IInputOutputArray, IInputOutputArray, CalibType, MCvTermCriteria, out Mat[], out Mat[])

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

public static double CalibrateCamera(MCvPoint3D32f[][] objectPoints, PointF[][] imagePoints, Size imageSize, IInputOutputArray cameraMatrix, IInputOutputArray distortionCoeffs, CalibType calibrationType, MCvTermCriteria termCriteria, out Mat[] rotationVectors, out Mat[] translationVectors)

Parameters

objectPoints MCvPoint3D32f[][]: 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 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. Although the points are 3D, they all lie in the calibration pattern's XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig. In the old interface all the vectors of object points from different views are concatenated together.
imagePoints PointF[][]: In the new interface it is a vector of vectors of the projections of calibration pattern points. In the old interface all the vectors of object points from different views are concatenated together.
imageSize Size: Size of the image used only to initialize the camera intrinsic matrix.
cameraMatrix IInputOutputArray: Input/output 3x3 floating-point camera intrinsic matrix A [fx 0 cx; 0 fy cy; 0 0 1]. If CV_CALIB_USE_INTRINSIC_GUESS and/or CV_CALIB_FIX_ASPECT_RATION are specified, some or all of fx, fy, cx, cy must be initialized
distortionCoeffs IInputOutputArray: Input/output vector of distortion coefficients (k1,k2,p1,p2[,k3[,k4,k5,k6[,s1,s2,s3,s4[,τx,τy]]]]) of 4, 5, 8, 12 or 14 elements.
calibrationType CalibType: The camera calibration flags.
termCriteria MCvTermCriteria: The termination criteria
rotationVectors Mat[]: Output vector of rotation vectors (Rodrigues) estimated for each pattern view. That is, each i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter description) brings the calibration pattern from the object coordinate space (in which object points are specified) to the camera coordinate space. In more technical terms, the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space to camera coordinate space. Due to its duality, this tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate space.
translationVectors Mat[]: Output vector of translation vectors estimated for each pattern view, see parameter describtion above.

Returns

double: The final reprojection error

CalibrateHandEye(IInputArrayOfArrays, IInputArrayOfArrays, IInputArrayOfArrays, IInputArrayOfArrays, IOutputArray, IOutputArray, HandEyeCalibrationMethod)

Computes Hand-Eye calibration

public static void CalibrateHandEye(IInputArrayOfArrays rGripper2base, IInputArrayOfArrays tGripper2base, IInputArrayOfArrays rTarget2cam, IInputArrayOfArrays tTarget2cam, IOutputArray rCam2gripper, IOutputArray tCam2gripper, HandEyeCalibrationMethod method)

Parameters

rGripper2base IInputArrayOfArrays: Rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame. This is a vector (vector<Mat>) that contains the rotation matrices for all the transformations from gripper frame to robot base frame.
tGripper2base IInputArrayOfArrays: Translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame. This is a vector (vector<Mat>) that contains the translation vectors for all the transformations from gripper frame to robot base frame.
rTarget2cam IInputArrayOfArrays: Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame. This is a vector (vector<Mat>) that contains the rotation matrices for all the transformations from calibration target frame to camera frame.
tTarget2cam IInputArrayOfArrays: Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame. This is a vector (vector<Mat>) that contains the translation vectors for all the transformations from calibration target frame to camera frame.
rCam2gripper IOutputArray: Estimated rotation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame.
tCam2gripper IOutputArray: Estimated translation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame.
method HandEyeCalibrationMethod: One of the implemented Hand-Eye calibration method

CalibrationMatrixValues(IInputArray, Size, double, double, ref double, ref double, ref double, ref MCvPoint2D64f, ref double)

Computes various useful camera (sensor/lens) characteristics using the computed camera calibration matrix, image frame resolution in pixels and the physical aperture size

public static void CalibrationMatrixValues(IInputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, ref double fovx, ref double fovy, ref double focalLength, ref MCvPoint2D64f principalPoint, ref double aspectRatio)

Parameters

cameraMatrix IInputArray: The matrix of intrinsic parameters
imageSize Size: Image size in pixels
apertureWidth double: Aperture width in real-world units (optional input parameter). Set it to 0 if not used
apertureHeight double: Aperture width in real-world units (optional input parameter). Set it to 0 if not used
fovx double: Field of view angle in x direction in degrees
fovy double: Field of view angle in y direction in degrees
focalLength double: Focal length in real-world units
principalPoint MCvPoint2D64f: The principal point in real-world units
aspectRatio double: The pixel aspect ratio ~ fy/f

CamShift(IInputArray, ref Rectangle, MCvTermCriteria)

Implements CAMSHIFT object tracking algorithm ([Bradski98]). First, it finds an object center using cvMeanShift and, after that, calculates the object size and orientation.

public static RotatedRect CamShift(IInputArray probImage, ref Rectangle window, MCvTermCriteria criteria)

Parameters

probImage IInputArray: Back projection of object histogram
window Rectangle: Initial search window
criteria MCvTermCriteria: Criteria applied to determine when the window search should be finished

Returns

RotatedRect: Circumscribed box for the object, contains object size and orientation

Canny(IInputArray, IInputArray, IOutputArray, double, double, bool)

Finds the edges on the input dx, dy and marks them in the output image edges using the Canny algorithm. The smallest of threshold1 and threshold2 is used for edge linking, the largest - to find initial segments of strong edges.

public static void Canny(IInputArray dx, IInputArray dy, IOutputArray edges, double threshold1, double threshold2, bool l2Gradient = false)

Parameters

dx IInputArray: 16-bit x derivative of input image
dy IInputArray: 16-bit y derivative of input image
edges IOutputArray: Image to store the edges found by the function
threshold1 double: The first threshold
threshold2 double: The second threshold.
l2Gradient bool: a flag, indicating whether a more accurate norm should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default norm is enough ( L2gradient=false ).

Canny(IInputArray, IOutputArray, double, double, int, bool)

Finds the edges on the input image and marks them in the output image edges using the Canny algorithm. The smallest of threshold1 and threshold2 is used for edge linking, the largest - to find initial segments of strong edges.

public static void Canny(IInputArray image, IOutputArray edges, double threshold1, double threshold2, int apertureSize = 3, bool l2Gradient = false)

Parameters

image IInputArray: Input image
edges IOutputArray: Image to store the edges found by the function
threshold1 double: The first threshold
threshold2 double: The second threshold.
apertureSize int: Aperture parameter for Sobel operator
l2Gradient bool: a flag, indicating whether a more accurate norm should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default norm is enough ( L2gradient=false ).

CartToPolar(IInputArray, IInputArray, IOutputArray, IOutputArray, bool)

Calculates the magnitude and angle of 2D vectors. magnitude(I)=sqrt( x(I)^2+y(I)^2 ), angle(I)=atan2( y(I)/x(I) ) The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to 0.

public static void CartToPolar(IInputArray x, IInputArray y, IOutputArray magnitude, IOutputArray angle, bool angleInDegrees = false)

Parameters

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

CheckRange(IInputArray, bool, ref Point, double, double)

Check that every array element is neither NaN nor +- inf. The functions also check that each value is between minVal and maxVal. in the case of multi-channel arrays each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos, and then the functions either return false (when quiet=true) or throw an exception.

public static bool CheckRange(IInputArray arr, bool quiet, ref Point pos, double minVal, double maxVal)

Parameters

arr IInputArray: 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 Point: This will be filled with the position of the first outlier
minVal double: The inclusive lower boundary of valid values range
maxVal double: The exclusive upper boundary of valid values range

Returns

bool: If quiet, return true if all values are in range

Circle(IInputOutputArray, Point, int, MCvScalar, int, LineType, int)

Draws a simple or filled circle with given center and radius. The circle is clipped by ROI rectangle.

public static void Circle(IInputOutputArray img, Point center, int radius, MCvScalar color, int thickness = 1, LineType lineType = LineType.EightConnected, int shift = 0)

Parameters

img IInputOutputArray: Image where the circle is drawn
center Point: Center of the circle
radius int: Radius of the circle.
color MCvScalar: Color of the circle
thickness int: Thickness of the circle outline if positive, otherwise indicates that a filled circle has to be drawn
lineType LineType: Line type
shift int: Number of fractional bits in the center coordinates and radius value

ClipLine(Rectangle, ref Point, ref Point)

Calculates a part of the line segment which is entirely in the rectangle.

public static bool ClipLine(Rectangle rectangle, ref Point pt1, ref Point pt2)

Parameters

rectangle Rectangle: The rectangle
pt1 Point: First ending point of the line segment. It is modified by the function
pt2 Point: Second ending point of the line segment. It is modified by the function.

Returns

bool: It returns false if the line segment is completely outside the rectangle and true otherwise.

ColorChange(IInputArray, IInputArray, IOutputArray, float, float, float)

Given an original color image, two differently colored versions of this image can be mixed seamlessly.

public static void ColorChange(IInputArray src, IInputArray mask, IOutputArray dst, float redMul = 1, float greenMul = 1, float blueMul = 1)

Parameters

src IInputArray: Input 8-bit 3-channel image.
mask IInputArray: Input 8-bit 1 or 3-channel image.
dst IOutputArray: Output image with the same size and type as src .
redMul float: R-channel multiply factor. Multiplication factor is between .5 to 2.5.
greenMul float: G-channel multiply factor. Multiplication factor is between .5 to 2.5.
blueMul float: B-channel multiply factor. Multiplication factor is between .5 to 2.5.

Compare(IInputArray, IInputArray, IOutputArray, CmpType)

Compares the corresponding elements of two arrays and fills the destination mask array: dst(I)=src1(I) op src2(I), dst(I) is set to 0xff (all '1'-bits) if the particular relation between the elements is true and 0 otherwise. All the arrays must have the same type, except the destination, and the same size (or ROI size)

public static void Compare(IInputArray src1, IInputArray src2, IOutputArray dst, CmpType cmpOp)

Parameters

src1 IInputArray: The first image to compare with
src2 IInputArray: The second image to compare with
dst IOutputArray: dst(I) is set to 0xff (all '1'-bits) if the particular relation between the elements is true and 0 otherwise.
cmpOp CmpType: The comparison operator type

CompareHist(IInputArray, IInputArray, HistogramCompMethod)

Compares two histograms.

public static double CompareHist(IInputArray h1, IInputArray h2, HistogramCompMethod method)

Parameters

h1 IInputArray: First compared histogram.
h2 IInputArray: Second compared histogram of the same size as H1 .
method HistogramCompMethod: Comparison method

Returns

double: The distance between the histogram

Compute(IStereoMatcher, IInputArray, IInputArray, IOutputArray)

Computes disparity map for the specified stereo pair

public static void Compute(this IStereoMatcher matcher, IInputArray left, IInputArray right, IOutputArray disparity)

Parameters

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

ComputeCorrespondEpilines(IInputArray, int, IInputArray, IOutputArray)

For every point in one of the two images of stereo-pair the function cvComputeCorrespondEpilines finds equation of a line that contains the corresponding point (i.e. projection of the same 3D point) in the other image. Each line is encoded by a vector of 3 elements l=[a,b,c]^T, so that: l^T*[x, y, 1]^T=0, or ax + by + c = 0 From the fundamental matrix definition (see cvFindFundamentalMatrix discussion), line l2 for a point p1 in the first image (which_image=1) can be computed as: l2=Fp1 and the line l1 for a point p2 in the second image (which_image=1) can be computed as: l1=F^Tp2Line coefficients are defined up to a scale. They are normalized (a2+b2=1) are stored into correspondent_lines

public static void ComputeCorrespondEpilines(IInputArray points, int whichImage, IInputArray fundamentalMatrix, IOutputArray correspondentLines)

Parameters

points IInputArray: The input points. 2xN, Nx2, 3xN or Nx3 array (where N number of points). Multi-channel 1xN or Nx1 array is also acceptable.
whichImage int: Index of the image (1 or 2) that contains the points
fundamentalMatrix IInputArray: Fundamental matrix
correspondentLines IOutputArray: Computed epilines, 3xN or Nx3 array

ConnectedComponents(IInputArray, IOutputArray, LineType, DepthType, ConnectedComponentsAlgorithmsTypes)

Computes the connected components labeled image of boolean image

public static int ConnectedComponents(IInputArray image, IOutputArray labels, LineType connectivity = LineType.EightConnected, DepthType labelType = DepthType.Cv32S, ConnectedComponentsAlgorithmsTypes cclType = ConnectedComponentsAlgorithmsTypes.Default)

Parameters

image IInputArray: The boolean image
labels IOutputArray: The connected components labeled image of boolean image
connectivity LineType: 4 or 8 way connectivity
labelType DepthType: 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 ConnectedComponentsAlgorithmsTypes: connected components algorithm type

Returns

int: N, the total number of labels [0, N-1] where 0 represents the background label.

ConnectedComponentsWithStats(IInputArray, IOutputArray, IOutputArray, IOutputArray, LineType, DepthType, ConnectedComponentsAlgorithmsTypes)

Computes the connected components labeled image of boolean image

public static int ConnectedComponentsWithStats(IInputArray image, IOutputArray labels, IOutputArray stats, IOutputArray centroids, LineType connectivity = LineType.EightConnected, DepthType labelType = DepthType.Cv32S, ConnectedComponentsAlgorithmsTypes cclType = ConnectedComponentsAlgorithmsTypes.Default)

Parameters

image IInputArray: The boolean image
labels IOutputArray: The connected components labeled image of boolean image
stats IOutputArray: 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. The data type is CV_32S
centroids IOutputArray: Centroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
connectivity LineType: 4 or 8 way connectivity
labelType DepthType: 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 ConnectedComponentsAlgorithmsTypes: connected components algorithm type

Returns

int: N, the total number of labels [0, N-1] where 0 represents the background label.

ContourArea(IInputArray, bool)

Calculates area of the whole contour or contour section.

public static double ContourArea(IInputArray contour, bool oriented = false)

Parameters

contour IInputArray: Input vector of 2D points (contour vertices), stored in std::vector or Mat.
oriented bool: Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is false, which means that the absolute value is returned.

Returns

double: The area of the whole contour or contour section

ConvertMaps(IInputArray, IInputArray, IOutputArray, IOutputArray, DepthType, int, bool)

Converts image transformation maps from one representation to another.

public static void ConvertMaps(IInputArray map1, IInputArray map2, IOutputArray dstmap1, IOutputArray dstmap2, DepthType dstmap1Depth, int dstmap1Channels, bool nninterpolation = false)

Parameters

map1 IInputArray: The first input map of type CV_16SC2 , CV_32FC1 , or CV_32FC2 .
map2 IInputArray: The second input map of type CV_16UC1 , CV_32FC1 , or none (empty matrix), respectively.
dstmap1 IOutputArray: The first output map that has the type dstmap1type and the same size as src .
dstmap2 IOutputArray: The second output map.
dstmap1Depth DepthType: Depth type of the first output map that should be CV_16SC2 , CV_32FC1 , or CV_32FC2.
dstmap1Channels int: The number of channels in the dst map.
nninterpolation bool: Flag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.

ConvertPointsFromHomogeneous(IInputArray, IOutputArray)

Converts points from homogeneous to Euclidean space.

public static void ConvertPointsFromHomogeneous(IInputArray src, IOutputArray dst)

Parameters

src IInputArray: Input vector of N-dimensional points.
dst IOutputArray: Output vector of N-1-dimensional points.

ConvertPointsToHomogeneous(IInputArray, IOutputArray)

Converts points from Euclidean to homogeneous space.

public static void ConvertPointsToHomogeneous(IInputArray src, IOutputArray dst)

Parameters

src IInputArray: Input vector of N-dimensional points.
dst IOutputArray: Output vector of N+1-dimensional points.

ConvertScaleAbs(IInputArray, IOutputArray, double, double)

Similar to cvCvtScale but it stores absolute values of the conversion results: dst(I)=abs(src(I)*scale + (shift,shift,...)) The function supports only destination arrays of 8u (8-bit unsigned integers) type, for other types the function can be emulated by combination of cvConvertScale and cvAbs functions.

public static void ConvertScaleAbs(IInputArray src, IOutputArray dst, double scale, double shift)

Parameters

src IInputArray: Source array
dst IOutputArray: Destination array (should have 8u depth).
scale double: ScaleAbs factor
shift double: Value added to the scaled source array elements

ConvexHull(IInputArray, IOutputArray, bool, bool)

The function cvConvexHull2 finds convex hull of 2D point set using Sklansky's algorithm.

public static void ConvexHull(IInputArray points, IOutputArray hull, bool clockwise = false, bool returnPoints = true)

Parameters

points IInputArray: Input 2D point set
hull IOutputArray: Output convex hull. It is either an integer vector of indices or vector of points. In the first case, the hull elements are 0-based indices of the convex hull points in the original array (since the set of convex hull points is a subset of the original point set). In the second case, hull elements are the convex hull points themselves.
clockwise bool: Orientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.
returnPoints bool: Operation flag. In case of a matrix, when the flag is true, the function returns convex hull points. Otherwise, it returns indices of the convex hull points. When the output array is std::vector, the flag is ignored, and the output depends on the type of the vector

ConvexHull(PointF[], bool)

Finds convex hull of 2D point set using Sklansky's algorithm

public static PointF[] ConvexHull(PointF[] points, bool clockwise = false)

Parameters

points PointF[]: The points to find convex hull from
clockwise bool: Orientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.

Returns

PointF[]: The convex hull of the points

ConvexityDefects(IInputArray, IInputArray, IOutputArray)

Finds the convexity defects of a contour.

public static void ConvexityDefects(IInputArray contour, IInputArray convexhull, IOutputArray convexityDefects)

Parameters

contour IInputArray: Input contour
convexhull IInputArray: Convex hull obtained using ConvexHull that should contain pointers or indices to the contour points, not the hull points themselves, i.e. return_points parameter in cvConvexHull2 should be 0
convexityDefects IOutputArray: 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.

CopyMakeBorder(IInputArray, IOutputArray, int, int, int, int, BorderType, MCvScalar)

Copies the source 2D array into interior of destination array and makes a border of the specified type around the copied area. The function is useful when one needs to emulate border type that is different from the one embedded into a specific algorithm implementation. For example, morphological functions, as well as most of other filtering functions in OpenCV, internally use replication border type, while the user may need zero border or a border, filled with 1's or 255's

public static void CopyMakeBorder(IInputArray src, IOutputArray dst, int top, int bottom, int left, int right, BorderType bordertype, MCvScalar value = default)

Parameters

src IInputArray: The source image
dst IOutputArray: The destination image
top int: Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate.
bottom int: Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate.
left int: Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate.
right int: Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate.
bordertype BorderType: Type of the border to create around the copied source image rectangle
value MCvScalar: Value of the border pixels if bordertype=CONSTANT

CornerHarris(IInputArray, IOutputArray, int, int, double, BorderType)

Runs the Harris edge detector on image. Similarly to cvCornerMinEigenVal and cvCornerEigenValsAndVecs, for each pixel it calculates 2x2 gradient covariation matrix M over block_size x block_size neighborhood. Then, it stores det(M) - k*trace(M)^2 to the destination image. Corners in the image can be found as local maxima of the destination image.

public static void CornerHarris(IInputArray image, IOutputArray harrisResponse, int blockSize, int apertureSize = 3, double k = 0.04, BorderType borderType = BorderType.Default)

Parameters

image IInputArray: Input image
harrisResponse IOutputArray: Image to store the Harris detector responces. Should have the same size as image
blockSize int: Neighborhood size
apertureSize int: Aperture parameter for Sobel operator (see cvSobel). format. In the case of floating-point input format this parameter is the number of the fixed float filter used for differencing.
k double: Harris detector free parameter.
borderType BorderType: Pixel extrapolation method.

CornerSubPix(IInputArray, IInputOutputArray, Size, Size, MCvTermCriteria)

Iterates to find the sub-pixel accurate location of corners, or radial saddle points

public static void CornerSubPix(IInputArray image, IInputOutputArray corners, Size win, Size zeroZone, MCvTermCriteria criteria)

Parameters

image IInputArray: Input image
corners IInputOutputArray: Initial coordinates of the input corners and refined coordinates on output
win Size: Half sizes of the search window. For example, if win=(5,5) then 52+1 x 52+1 = 11 x 11 search window is used
zeroZone Size: Half size of the dead region in the middle of the search zone over which the summation in formulae 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 size
criteria MCvTermCriteria: Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after certain number of iteration or when a required accuracy is achieved. The criteria may specify either of or both the maximum number of iteration and the required accuracy

CorrectMatches(IInputArray, IInputArray, IInputArray, IOutputArray, IOutputArray)

Refines coordinates of corresponding points.

public static void CorrectMatches(IInputArray f, IInputArray points1, IInputArray points2, IOutputArray newPoints1, IOutputArray newPoints2)

Parameters

f IInputArray: 3x3 fundamental matrix.
points1 IInputArray: 1xN array containing the first set of points.
points2 IInputArray: 1xN array containing the second set of points.
newPoints1 IOutputArray: The optimized points1.
newPoints2 IOutputArray: The optimized points2.

CountNonZero(IInputArray)

Returns the number of non-zero elements in arr: result = sumI arr(I)!=0 In case of IplImage both ROI and COI are supported.

public static int CountNonZero(IInputArray arr)

Parameters

arr IInputArray: The image

Returns

int: the number of non-zero elements in image

CreateHanningWindow(IOutputArray, Size, DepthType)

This function computes a Hanning window coefficients in two dimensions.

public static void CreateHanningWindow(IOutputArray dst, Size winSize, DepthType type)

Parameters

dst IOutputArray: Destination array to place Hann coefficients in
winSize Size: The window size specifications
type DepthType: Created array type

CvArrToMat(nint, bool, bool, int)

Converts CvMat, IplImage , or CvMatND to Mat.

public static Mat CvArrToMat(nint arr, bool copyData = false, bool allowND = true, int coiMode = 0)

Parameters

arr nint: Input CvMat, IplImage , or CvMatND.
copyData bool: When false (default value), no data is copied and only the new header is created, in this case, the original array should not be deallocated while the new matrix header is used; if the parameter is true, all the data is copied and you may deallocate the original array right after the conversion.
allowND bool: When true (default value), CvMatND is converted to 2-dimensional Mat, if it is possible (see the discussion below); if it is not possible, or when the parameter is false, the function will report an error
coiMode int: Parameter specifying how the IplImage COI (when set) is handled. If coiMode=0 and COI is set, the function reports an error. If coiMode=1 , the function never reports an error. Instead, it returns the header to the whole original image and you will have to check and process COI manually.

Returns

Mat: The Mat header

CvtColor(IInputArray, IOutputArray, ColorConversion, int)

Converts input image from one color space to another. The function ignores colorModel and channelSeq fields of IplImage header, so the source image color space should be specified correctly (including order of the channels in case of RGB space, e.g. BGR means 24-bit format with B0 G0 R0 B1 G1 R1 ... layout, whereas RGB means 24-bit format with R0 G0 B0 R1 G1 B1 ... layout).

public static void CvtColor(IInputArray src, IOutputArray dst, ColorConversion code, int dstCn = 0)

Parameters

src IInputArray: The source 8-bit (8u), 16-bit (16u) or single-precision floating-point (32f) image
dst IOutputArray: The destination image of the same data type as the source one. The number of channels may be different
code ColorConversion: Color conversion operation that can be specifed using CV_src_color_space2dst_color_space constants
dstCn int: number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code .

CvtColor(IInputArray, IOutputArray, Type, Type)

public static void CvtColor(IInputArray src, IOutputArray dest, Type srcColor, Type destColor)

Parameters

src IInputArray: The source 8-bit (8u), 16-bit (16u) or single-precision floating-point (32f) image
dest IOutputArray: The destination image of the same data type as the source one. The number of channels may be different
srcColor Type: Source color type.
destColor Type: Destination color type

CvtColorTwoPlane(IInputArray, IInputArray, IOutputArray, ColorConversion)

Converts an image from one color space to another where the source image is stored in two planes.

public static void CvtColorTwoPlane(IInputArray src1, IInputArray src2, IOutputArray dst, ColorConversion code)

Parameters

src1 IInputArray: 8-bit image (CV_8U) of the Y plane.
src2 IInputArray: Image containing interleaved U/V plane.
dst IOutputArray: Output image.
code ColorConversion: Specifies the type of conversion. It can take any of the following values: COLOR_YUV2BGR_NV12 COLOR_YUV2RGB_NV12 COLOR_YUV2BGRA_NV12 COLOR_YUV2RGBA_NV12 COLOR_YUV2BGR_NV21 COLOR_YUV2RGB_NV21 COLOR_YUV2BGRA_NV21 COLOR_YUV2RGBA_NV21

Dct(IInputArray, IOutputArray, DctType)

Performs forward or inverse transform of 1D or 2D floating-point array

public static void Dct(IInputArray src, IOutputArray dst, DctType flags)

Parameters

src IInputArray: Source array, real 1D or 2D array
dst IOutputArray: Destination array of the same size and same type as the source
flags DctType: Transformation flags

Decolor(IInputArray, IOutputArray, IOutputArray)

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

public static void Decolor(IInputArray src, IOutputArray grayscale, IOutputArray colorBoost)

Parameters

src IInputArray: Input 8-bit 3-channel image.
grayscale IOutputArray: Output 8-bit 1-channel image.
colorBoost IOutputArray: Output 8-bit 3-channel image.

DecomposeEssentialMat(IInputArray, IOutputArray, IOutputArray, IOutputArray)

Decompose an essential matrix to possible rotations and translation.

public static void DecomposeEssentialMat(IInputArray e, IOutputArray r1, IOutputArray r2, IOutputArray t)

Parameters

e IInputArray: The input essential matrix.
r1 IOutputArray: One possible rotation matrix.
r2 IOutputArray: Another possible rotation matrix.
t IOutputArray: One possible translation.

Remarks

This function decomposes the essential matrix E using svd decomposition. In general, four possible poses exist for the decomposition of E. They are [R1,t], [R1,−t], [R2,t], [R2,−t]

DecomposeHomographyMat(IInputArray, IInputArray, IOutputArrayOfArrays, IOutputArrayOfArrays, IOutputArrayOfArrays)

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

public static int DecomposeHomographyMat(IInputArray h, IInputArray k, IOutputArrayOfArrays rotations, IOutputArrayOfArrays translations, IOutputArrayOfArrays normals)

Parameters

h IInputArray: The input homography matrix between two images.
k IInputArray: The input camera intrinsic matrix.
rotations IOutputArrayOfArrays: Array of rotation matrices.
translations IOutputArrayOfArrays: Array of translation matrices.
normals IOutputArrayOfArrays: Array of plane normal matrices.

Returns

int: Number of solutions

DecomposeProjectionMatrix(IInputArray, IOutputArray, IOutputArray, IOutputArray, IOutputArray, IOutputArray, IOutputArray, IOutputArray)

Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.

public static void DecomposeProjectionMatrix(IInputArray projMatrix, IOutputArray cameraMatrix, IOutputArray rotMatrix, IOutputArray transVect, IOutputArray rotMatrixX = null, IOutputArray rotMatrixY = null, IOutputArray rotMatrixZ = null, IOutputArray eulerAngles = null)

Parameters

projMatrix IInputArray: 3x4 input projection matrix P.
cameraMatrix IOutputArray: Output 3x3 camera intrinsic matrix A
rotMatrix IOutputArray: Output 3x3 external rotation matrix R.
transVect IOutputArray: Output 4x1 translation vector T.
rotMatrixX IOutputArray: Optional 3x3 rotation matrix around x-axis.
rotMatrixY IOutputArray: Optional 3x3 rotation matrix around y-axis.
rotMatrixZ IOutputArray: Optional 3x3 rotation matrix around z-axis.
eulerAngles IOutputArray: Optional three-element vector containing three Euler angles of rotation in degrees.

DefaultLoadUnmanagedModules(string[], string)

Attempts to load opencv modules from the specific location

public static bool DefaultLoadUnmanagedModules(string[] modules, string loadDirectory = null)

Parameters

modules string[]: The names of opencv modules. e.g. "opencv_core.dll" on windows.
loadDirectory string: The path to load the opencv modules. If null, will use the default path.

Returns

bool: True if all the modules has been loaded successfully

Demosaicing(IInputArray, IOutputArray, ColorConversion, int)

main function for all demosaicing processes

public static void Demosaicing(IInputArray src, IOutputArray dst, ColorConversion code, int dstCn = 0)

Parameters

src IInputArray: Input image: 8-bit unsigned or 16-bit unsigned
dst IOutputArray: Output image of the same size and depth as src
code ColorConversion: Color space conversion code
dstCn int: Number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.

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

public static void DenoiseTVL1(Mat[] observations, Mat result, double lambda, int niters)

Parameters

observations Mat[]: This array should contain one or more noised versions of the image that is to be restored.
result 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 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.

DestroyAllWindows()

Destroys all of the HighGUI windows.

public static void DestroyAllWindows()

DestroyWindow(string)

Destroys the window with a given name

public static void DestroyWindow(string name)

Parameters

name string: Name of the window to be destroyed

DetailEnhance(IInputArray, IOutputArray, float, float)

This filter enhances the details of a particular image.

public static void DetailEnhance(IInputArray src, IOutputArray dst, float sigmaS = 10, float sigmaR = 0.15)

Parameters

src IInputArray: Input 8-bit 3-channel image
dst IOutputArray: Output image with the same size and type as src
sigmaS float: Range between 0 to 200
sigmaR float: Range between 0 to 1

Determinant(IInputArray)

Returns determinant of the square matrix mat. The direct method is used for small matrices and Gaussian elimination is used for larger matrices. For symmetric positive-determined matrices it is also possible to run SVD with U=V=NULL and then calculate determinant as a product of the diagonal elements of W

public static double Determinant(IInputArray mat)

Parameters

mat IInputArray: The pointer to the matrix

Returns

double: determinant of the square matrix mat

Dft(IInputArray, IOutputArray, DxtType, int)

Performs forward or inverse transform of 1D or 2D floating-point array In case of real (single-channel) data, the packed format, borrowed from IPL, is used to to represent a result of forward Fourier transform or input for inverse Fourier transform

public static void Dft(IInputArray src, IOutputArray dst, DxtType flags = DxtType.Forward, int nonzeroRows = 0)

Parameters

src IInputArray: Source array, real or complex
dst IOutputArray: Destination array of the same size and same type as the source
flags DxtType: Transformation flags
nonzeroRows int: Number of nonzero rows to in the source array (in case of forward 2d transform), or a number of rows of interest in the destination array (in case of inverse 2d transform). If the value is negative, zero, or greater than the total number of rows, it is ignored. The parameter can be used to speed up 2d convolution/correlation when computing them via DFT. See the sample below

Dilate(IInputArray, IOutputArray, IInputArray, Point, int, BorderType, MCvScalar)

Dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken The function supports the in-place mode. Dilation can be applied several (iterations) times. In case of color image each channel is processed independently

public static void Dilate(IInputArray src, IOutputArray dst, IInputArray element, Point anchor, int iterations, BorderType borderType, MCvScalar borderValue)

Parameters

src IInputArray: Source image
dst IOutputArray: Destination image
element IInputArray: Structuring element used for erosion. If it is IntPtr.Zero, a 3x3 rectangular structuring element is used
anchor Point: Position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterations int: Number of times erosion is applied
borderType BorderType: Pixel extrapolation method
borderValue MCvScalar: Border value in case of a constant border

DistanceTransform(IInputArray, IOutputArray, IOutputArray, DistType, int, DistLabelType)

Calculates distance to closest zero pixel for all non-zero pixels of source image

public static void DistanceTransform(IInputArray src, IOutputArray dst, IOutputArray labels, DistType distanceType, int maskSize, DistLabelType labelType = DistLabelType.CComp)

Parameters

src IInputArray: Source 8-bit single-channel (binary) image.
dst IOutputArray: Output image with calculated distances (32-bit floating-point, single-channel).
labels IOutputArray: The optional output 2d array of labels of integer type and the same size as src and dst. Can be null if not needed
distanceType DistType: Type of distance
maskSize int: Size of distance transform mask; can be 3 or 5. In case of CV_DIST_L1 or CV_DIST_C the parameter is forced to 3, because 3x3 mask gives the same result as 5x5 yet it is faster.
labelType DistLabelType: Type of the label array to build. If labelType==CCOMP then each connected component of zeros in src (as well as all the non-zero pixels closest to the connected component) will be assigned the same label. If labelType==PIXEL then each zero pixel (and all the non-zero pixels closest to it) gets its own label.

Divide(IInputArray, IInputArray, IOutputArray, double, DepthType)

Divides one array by another: dst(I)=scale * src1(I)/src2(I), if src1!=IntPtr.Zero; dst(I)=scale/src2(I), if src1==IntPtr.Zero; All the arrays must have the same type, and the same size (or ROI size)

public static void Divide(IInputArray src1, IInputArray src2, IOutputArray dst, double scale = 1, DepthType dtype = DepthType.Default)

Parameters

src1 IInputArray: The first source array. If the pointer is IntPtr.Zero, the array is assumed to be all 1s.
src2 IInputArray: The second source array
dst IOutputArray: The destination array
scale double: Optional scale factor
dtype DepthType: Optional depth of the output array

DrawChessboardCorners(IInputOutputArray, Size, IInputArray, bool)

Draws the individual chessboard corners detected (as red circles) in case if the board was not found (pattern_was_found=0) or the colored corners connected with lines when the board was found (pattern_was_found != 0).

public static void DrawChessboardCorners(IInputOutputArray image, Size patternSize, IInputArray corners, bool patternWasFound)

Parameters

image IInputOutputArray: The destination image; it must be 8-bit color image
patternSize Size: The number of inner corners per chessboard row and column
corners IInputArray: The array of corners detected
patternWasFound bool: Indicates whether the complete board was found (!=0) or not (=0). One may just pass the return value cvFindChessboardCorners here.

DrawContours(IInputOutputArray, IInputArrayOfArrays, int, MCvScalar, int, LineType, IInputArray, int, Point)

Draws contours outlines or filled contours.

public static void DrawContours(IInputOutputArray image, IInputArrayOfArrays contours, int contourIdx, MCvScalar color, int thickness = 1, LineType lineType = LineType.EightConnected, IInputArray hierarchy = null, int maxLevel = 2147483647, Point offset = default)

Parameters

image IInputOutputArray: Image where the contours are to be drawn. Like in any other drawing function, the contours are clipped with the ROI
contours IInputArrayOfArrays: 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 MCvScalar: Color of the contours
thickness int: Thickness of lines the contours are drawn with. If it is negative the contour interiors are drawn
lineType LineType: Type of the contour segments
hierarchy IInputArray: 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 0, only contour is drawn. If 1, the contour and all contours after it on the same level are drawn. If 2, all contours after and all contours one level below the contours are drawn, etc. If the value is negative, the function does not draw the contours following after contour but draws child contours of contour up to abs(maxLevel)-1 level.
offset Point: Shift all the point coordinates by the specified value. It is useful in case if the contours retrieved in some image ROI and then the ROI offset needs to be taken into account during the rendering.

DrawMarker(IInputOutputArray, Point, MCvScalar, MarkerTypes, int, int, LineType)

Draws a marker on a predefined position in an image.

public static void DrawMarker(IInputOutputArray img, Point position, MCvScalar color, MarkerTypes markerType, int markerSize = 20, int thickness = 1, LineType lineType = LineType.EightConnected)

Parameters

img IInputOutputArray: Image.
position Point: The point where the crosshair is positioned.
color MCvScalar: Line color.
markerType MarkerTypes: The specific type of marker you want to use
markerSize int: The length of the marker axis [default = 20 pixels]
thickness int: Line thickness.
lineType LineType: Type of the line

EMD(IInputArray, IInputArray, DistType, IInputArray, float[], IOutputArray)

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

public static float EMD(IInputArray signature1, IInputArray signature2, DistType distType, IInputArray cost = null, float[] lowerBound = null, IOutputArray flow = null)

Parameters

signature1 IInputArray: First signature, a size1 x dims + 1 floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used.
signature2 IInputArray: Second signature of the same format as signature1 , though the number of rows may be different. The total weights may be different. In this case an extra 'dummy' point is added to either signature1 or signature2
distType DistType: Used metric. CV_DIST_L1, CV_DIST_L2 , and CV_DIST_C stand for one of the standard metrics. CV_DIST_USER means that a pre-calculated cost matrix cost is used.
cost IInputArray: User-defined size1 x size2 cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
lowerBound float[]: Optional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (the signature matrices have a single column).
flow IOutputArray: Resultant size1 x size2 flow matrix

Returns

float: The 'minimal work' distance between two weighted point configurations.

EdgePreservingFilter(IInputArray, IOutputArray, EdgePreservingFilterFlag, float, float)

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

public static void EdgePreservingFilter(IInputArray src, IOutputArray dst, EdgePreservingFilterFlag flags = EdgePreservingFilterFlag.RecursFilter, float sigmaS = 60, float sigmaR = 0.4)

Parameters

src IInputArray: Input 8-bit 3-channel image
dst IOutputArray: Output 8-bit 3-channel image
flags EdgePreservingFilterFlag: Edge preserving filters
sigmaS float: Range between 0 to 200
sigmaR float: Range between 0 to 1

Eigen(IInputArray, IOutputArray, IOutputArray)

Computes eigenvalues and eigenvectors of a symmetric matrix

public static void Eigen(IInputArray src, IOutputArray eigenValues, IOutputArray eigenVectors = null)

Parameters

src IInputArray: The input symmetric square matrix, modified during the processing
eigenValues IOutputArray: The output vector of eigenvalues, stored in the descending order (order of eigenvalues and eigenvectors is syncronized, of course)
eigenVectors IOutputArray: The output matrix of eigenvectors, stored as subsequent rows

Examples

To calculate the largest eigenvector/-value set lowindex = highindex = 1. For legacy reasons this function always returns a square matrix the same size as the source matrix with eigenvectors and a vector the length of the source matrix with eigenvalues. The selected eigenvectors/-values are always in the first highindex - lowindex + 1 rows.

Remarks

Currently the function is slower than cvSVD yet less accurate, so if A is known to be positivelydefined (for example, it is a covariance matrix)it is recommended to use cvSVD to find eigenvalues and eigenvectors of A, especially if eigenvectors are not required.

Ellipse(IInputOutputArray, RotatedRect, MCvScalar, int, LineType)

Draws a simple or thick elliptic arc or fills an ellipse sector. The arc is clipped by ROI rectangle. A piecewise-linear approximation is used for antialiased arcs and thick arcs. All the angles are given in degrees.

public static void Ellipse(IInputOutputArray img, RotatedRect box, MCvScalar color, int thickness = 1, LineType lineType = LineType.EightConnected)

Parameters

img IInputOutputArray: Image
box RotatedRect: Alternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.
color MCvScalar: Ellipse color
thickness int: Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineType LineType: Type of the ellipse boundary

Ellipse(IInputOutputArray, Point, Size, double, double, double, MCvScalar, int, LineType, int)

public static void Ellipse(IInputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, MCvScalar color, int thickness = 1, LineType lineType = LineType.EightConnected, int shift = 0)

Parameters

img IInputOutputArray: Image
center 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 MCvScalar: Ellipse color
thickness int: Thickness of the ellipse arc
lineType LineType: Type of the ellipse boundary
shift int: Number of fractional bits in the center coordinates and axes' values

EqualizeHist(IInputArray, IOutputArray)

The algorithm normalizes brightness and increases contrast of the image

public static void EqualizeHist(IInputArray src, IOutputArray dst)

Parameters

src IInputArray: The input 8-bit single-channel image
dst IOutputArray: The output image of the same size and the same data type as src

Erode(IInputArray, IOutputArray, IInputArray, Point, int, BorderType, MCvScalar)

Erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken: dst=erode(src,element): dst(x,y)=min((x',y') in element)) src(x+x',y+y') The function supports the in-place mode. Erosion can be applied several (iterations) times. In case of color image each channel is processed independently.

public static void Erode(IInputArray src, IOutputArray dst, IInputArray element, Point anchor, int iterations, BorderType borderType, MCvScalar borderValue)

Parameters

src IInputArray: Source image.
dst IOutputArray: Destination image
element IInputArray: Structuring element used for erosion. If it is IntPtr.Zero, a 3x3 rectangular structuring element is used.
anchor Point: Position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterations int: Number of times erosion is applied.
borderType BorderType: Pixel extrapolation method
borderValue MCvScalar: Border value in case of a constant border, use Constant for default

ErrorStr(int)

Returns the textual description for the specified error status code. In case of unknown status the function returns NULL pointer.

public static string ErrorStr(int status)

Parameters

status int: The error status

Returns

string: the textual description for the specified error status code.

EstimateAffine2D(IInputArray, IInputArray, IOutputArray, RobustEstimationAlgorithm, double, int, double, int)

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

public static Mat EstimateAffine2D(IInputArray from, IInputArray to, IOutputArray inliners = null, RobustEstimationAlgorithm method = RobustEstimationAlgorithm.Ransac, double ransacReprojThreshold = 3, int maxIters = 2000, double confidence = 0.99, int refineIters = 10)

Parameters

from IInputArray: First input 2D point set containing (X,Y).
to IInputArray: Second input 2D point set containing (x,y).
inliners IOutputArray: Output vector indicating which points are inliers (1-inlier, 0-outlier).
method RobustEstimationAlgorithm: Robust method used to compute transformation.
ransacReprojThreshold double: Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier. Applies only to RANSAC.
maxIters int: The maximum number of robust method iterations.
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.
refineIters int: Maximum number of iterations of refining algorithm (Levenberg-Marquardt). Passing 0 will disable refining, so the output matrix will be output of robust method.

Returns

Mat: Output 2D affine transformation matrix 2×3 or empty matrix if transformation could not be estimated.

EstimateAffine2D(PointF[], PointF[], IOutputArray, RobustEstimationAlgorithm, double, int, double, int)

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

public static Mat EstimateAffine2D(PointF[] from, PointF[] to, IOutputArray inliners = null, RobustEstimationAlgorithm method = RobustEstimationAlgorithm.Ransac, double ransacReprojThreshold = 3, int maxIters = 2000, double confidence = 0.99, int refineIters = 10)

Parameters

from PointF[]: First input 2D point set containing (X,Y).
to PointF[]: Second input 2D point set containing (x,y).
inliners IOutputArray: Output vector indicating which points are inliers (1-inlier, 0-outlier).
method RobustEstimationAlgorithm: Robust method used to compute transformation.
ransacReprojThreshold double: Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier. Applies only to RANSAC.
maxIters int: The maximum number of robust method iterations.
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.
refineIters int: Maximum number of iterations of refining algorithm (Levenberg-Marquardt). Passing 0 will disable refining, so the output matrix will be output of robust method.

Returns

Mat: Output 2D affine transformation matrix 2×3 or empty matrix if transformation could not be estimated.

EstimateAffine3D(IInputArray, IInputArray, IOutputArray, IOutputArray, double, double)

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

public static int EstimateAffine3D(IInputArray src, IInputArray dst, IOutputArray affineEstimate, IOutputArray inliers, double ransacThreshold = 3, double confidence = 0.99)

Parameters

src IInputArray: First input 3D point set.
dst IInputArray: Second input 3D point set.
affineEstimate IOutputArray: Output 3D affine transformation matrix 3 x 4
inliers IOutputArray: 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.

Returns

int: the result

EstimateAffine3D(MCvPoint3D32f[], MCvPoint3D32f[], out Matrix<double>, out byte[], double, double)

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

public static int EstimateAffine3D(MCvPoint3D32f[] src, MCvPoint3D32f[] dst, out Matrix<double> estimate, out byte[] inliers, double ransacThreshold, double confidence)

Parameters

src MCvPoint3D32f[]: First input 3D point set.
dst MCvPoint3D32f[]: Second input 3D point set.
estimate Matrix<double>: Output 3D affine transformation matrix.
inliers byte[]: 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.

Returns

int: The result

EstimateAffinePartial2D(IInputArray, IInputArray, IOutputArray, RobustEstimationAlgorithm, double, int, double, int)

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

public static Mat EstimateAffinePartial2D(IInputArray from, IInputArray to, IOutputArray inliners, RobustEstimationAlgorithm method, double ransacReprojThreshold, int maxIters, double confidence, int refineIters)

Parameters

from IInputArray: First input 2D point set.
to IInputArray: Second input 2D point set.
inliners IOutputArray: Output vector indicating which points are inliers.
method RobustEstimationAlgorithm: Robust method used to compute transformation.
ransacReprojThreshold double: Maximum reprojection error in the RANSAC algorithm to consider a point as an inlier. Applies only to RANSAC.
maxIters int: The maximum number of robust method iterations.
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.
refineIters int: Maximum number of iterations of refining algorithm (Levenberg-Marquardt). Passing 0 will disable refining, so the output matrix will be output of robust method.

Returns

Mat: Output 2D affine transformation (4 degrees of freedom) matrix 2×3 or empty matrix if transformation could not be estimated.

EstimateChessboardSharpness(IInputArray, Size, IInputArray, float, bool, IOutputArray)

Estimates the sharpness of a detected chessboard. Image sharpness, as well as brightness, are a critical parameter for accuracte camera calibration. For accessing these parameters for filtering out problematic calibraiton images, this method calculates edge profiles by traveling from black to white chessboard cell centers. Based on this, the number of pixels is calculated required to transit from black to white. This width of the transition area is a good indication of how sharp the chessboard is imaged and should be below ~3.0 pixels.

public static MCvScalar EstimateChessboardSharpness(IInputArray image, Size patternSize, IInputArray corners, float riseDistance = 0.8, bool vertical = false, IOutputArray sharpness = null)

Parameters

image IInputArray: Gray image used to find chessboard corners
patternSize Size: Size of a found chessboard pattern
corners IInputArray: Corners found by findChessboardCorners(SB)
riseDistance float: Rise distance 0.8 means 10% ... 90% of the final signal strength
vertical bool: By default edge responses for horizontal lines are calculated
sharpness IOutputArray: Optional output array with a sharpness value for calculated edge responses

Returns

MCvScalar: Scalar(average sharpness, average min brightness, average max brightness,0)

Exp(IInputArray, IOutputArray)

Calculates exponent of every element of input array: dst(I)=exp(src(I)) Maximum relative error is 7e-6. Currently, the function converts denormalized values to zeros on output

public static void Exp(IInputArray src, IOutputArray dst)

Parameters

src IInputArray: The source array
dst IOutputArray: The destination array, it should have double type or the same type as the source

ExtractChannel(IInputArray, IOutputArray, int)

Extract the specific channel from the image

public static void ExtractChannel(IInputArray src, IOutputArray dst, int coi)

Parameters

src IInputArray: The source image
dst IOutputArray: The channel
coi int: 0 based index of the channel to be extracted

FastNlMeansDenoising(IInputArray, IOutputArray, float, int, int)

Perform image denoising using Non-local Means Denoising algorithm: http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ with several computational optimizations. Noise expected to be a Gaussian white noise.

public static void FastNlMeansDenoising(IInputArray src, IOutputArray dst, float h = 3, int templateWindowSize = 7, int searchWindowSize = 21)

Parameters

src IInputArray: Input 8-bit 1-channel, 2-channel or 3-channel image.
dst IOutputArray: 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.
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.

FastNlMeansDenoisingColored(IInputArray, IOutputArray, float, float, int, int)

Perform image denoising using Non-local Means Denoising algorithm (modified for color image): http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ with several computational optimizations. Noise expected to be a Gaussian white noise. The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

public static void FastNlMeansDenoisingColored(IInputArray src, IOutputArray dst, float h = 3, float hColor = 3, int templateWindowSize = 7, int searchWindowSize = 21)

Parameters

src IInputArray: Input 8-bit 1-channel, 2-channel or 3-channel image.
dst IOutputArray: 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.
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.
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.

FillConvexPoly(IInputOutputArray, IInputArray, MCvScalar, LineType, int)

Fills convex polygon interior. This function is much faster than The function cvFillPoly and can fill not only the convex polygons but any monotonic polygon, i.e. a polygon whose contour intersects every horizontal line (scan line) twice at the most

public static void FillConvexPoly(IInputOutputArray img, IInputArray points, MCvScalar color, LineType lineType = LineType.EightConnected, int shift = 0)

Parameters

img IInputOutputArray: Image
points IInputArray: Array of pointers to a single polygon
color MCvScalar: Polygon color
lineType LineType: Type of the polygon boundaries
shift int: Number of fractional bits in the vertex coordinates

FillPoly(IInputOutputArray, IInputArray, MCvScalar, LineType, int, Point)

Fills the area bounded by one or more polygons.

public static void FillPoly(IInputOutputArray img, IInputArray points, MCvScalar color, LineType lineType = LineType.EightConnected, int shift = 0, Point offset = default)

Parameters

img IInputOutputArray: Image.
points IInputArray: Array of polygons where each polygon is represented as an array of points.
color MCvScalar: Polygon color
lineType LineType: Type of the polygon boundaries.
shift int: Number of fractional bits in the vertex coordinates.
offset Point: Optional offset of all points of the contours.

Filter2D(IInputArray, IOutputArray, IInputArray, Point, double, BorderType)

Applies arbitrary linear filter to the image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values from the nearest pixels that is inside the image

public static void Filter2D(IInputArray src, IOutputArray dst, IInputArray kernel, Point anchor, double delta = 0, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: The source image
dst IOutputArray: The destination image
kernel IInputArray: Convolution kernel, single-channel floating point matrix. If you want to apply different kernels to different channels, split the image using cvSplit into separate color planes and process them individually
anchor Point: The anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor shoud lie within the kernel. The special default value (-1,-1) means that it is at the kernel center
delta double: The optional value added to the filtered pixels before storing them in dst
borderType BorderType: The pixel extrapolation method.

FilterSpeckles(IInputOutputArray, double, int, double, IInputOutputArray)

Filters off small noise blobs (speckles) in the disparity map.

public static void FilterSpeckles(IInputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, IInputOutputArray buf = null)

Parameters

img IInputOutputArray: 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 IInputOutputArray: The optional temporary buffer to avoid memory allocation within the function.

Find4QuadCornerSubpix(IInputArray, IInputOutputArray, Size)

Finds subpixel-accurate positions of the chessboard corners

public static bool Find4QuadCornerSubpix(IInputArray image, IInputOutputArray corners, Size regionSize)

Parameters

image IInputArray: Source chessboard view; it must be 8-bit grayscale or color image
corners IInputOutputArray: Pointer to the output array of corners(PointF) detected
regionSize Size: region size

Returns

bool: True if successful

FindChessboardCorners(IInputArray, Size, IOutputArray, CalibCbType)

Attempts to determine whether the input image is a view of the chessboard pattern and locate internal chessboard corners

public static bool FindChessboardCorners(IInputArray image, Size patternSize, IOutputArray corners, CalibCbType flags = CalibCbType.AdaptiveThresh | CalibCbType.NormalizeImage)

Parameters

image IInputArray: Source chessboard view; it must be 8-bit grayscale or color image
patternSize Size: The number of inner corners per chessboard row and column
corners IOutputArray: Pointer to the output array of corners(PointF) detected
flags CalibCbType: Various operation flags

Returns

bool: True if all the corners have been found and they have been placed in a certain order (row by row, left to right in every row), otherwise, if the function fails to find all the corners or reorder them, it returns 0

Remarks

The coordinates detected are approximate, and to determine their position more accurately, the user may use the function cvFindCornerSubPix

FindChessboardCornersSB(IInputArray, Size, IOutputArray, CalibCbType)

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

public static bool FindChessboardCornersSB(IInputArray image, Size patternSize, IOutputArray corners, CalibCbType flags = CalibCbType.Default)

Parameters

image IInputArray: 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 = cv::Size(points_per_row,points_per_colum) = cv::Size(columns,rows) ).
corners IOutputArray: Output array of detected corners.
flags CalibCbType: Various operation flags

Returns

bool: True if chessboard corners found

FindCirclesGrid(IInputArray, Size, IOutputArray, CalibCgType, Feature2D)

Finds centers in the grid of circles

public static bool FindCirclesGrid(IInputArray image, Size patternSize, IOutputArray centers, CalibCgType flags, Feature2D featureDetector)

Parameters

image IInputArray: Source chessboard view
patternSize Size: The number of inner circle per chessboard row and column
centers IOutputArray: output array of detected centers.
flags CalibCgType: Various operation flags
featureDetector Feature2D: The feature detector. Use a SimpleBlobDetector for default

Returns

bool: True if grid found.

FindCirclesGrid(Image<Gray, byte>, Size, CalibCgType, Feature2D)

Finds centers in the grid of circles

public static PointF[] FindCirclesGrid(Image<Gray, byte> image, Size patternSize, CalibCgType flags, Feature2D featureDetector)

Parameters

image Image<Gray, byte>: Source chessboard view
patternSize Size: The number of inner circle per chessboard row and column
flags CalibCgType: Various operation flags
featureDetector Feature2D: The feature detector. Use a SimpleBlobDetector for default

Returns

PointF[]: The center of circles detected if the chess board pattern is found, otherwise null is returned

FindContourTree(IInputOutputArray, IOutputArray, ChainApproxMethod, Point)

Retrieves contours from the binary image as a contour tree. The pointer firstContour is filled by the function. It is provided as a convenient way to obtain the hierarchy value as int[,]. The function modifies the source image content

public static int[,] FindContourTree(IInputOutputArray image, IOutputArray contours, ChainApproxMethod method, Point offset = default)

Parameters

image IInputOutputArray: The source 8-bit single channel image. Non-zero pixels are treated as 1s, zero pixels remain 0s - that is image treated as binary. To get such a binary image from grayscale, one may use cvThreshold, cvAdaptiveThreshold or cvCanny. The function modifies the source image content
contours IOutputArray: Detected contours. Each contour is stored as a vector of points.
method ChainApproxMethod: Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
offset Point: 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

Returns

int[,]: The contour hierarchy

FindContours(IInputOutputArray, IOutputArray, IOutputArray, RetrType, ChainApproxMethod, Point)

Retrieves contours from the binary image and returns the number of retrieved contours. The pointer firstContour is filled by the function. It will contain pointer to the first most outer contour or IntPtr.Zero if no contours is detected (if the image is completely black). Other contours may be reached from firstContour using h_next and v_next links. The sample in cvDrawContours discussion shows how to use contours for connected component detection. Contours can be also used for shape analysis and object recognition - see squares.c in OpenCV sample directory The function modifies the source image content

public static void FindContours(IInputOutputArray image, IOutputArray contours, IOutputArray hierarchy, RetrType mode, ChainApproxMethod method, Point offset = default)

Parameters

image IInputOutputArray: The source 8-bit single channel image. Non-zero pixels are treated as 1s, zero pixels remain 0s - that is image treated as binary. To get such a binary image from grayscale, one may use cvThreshold, cvAdaptiveThreshold or cvCanny. The function modifies the source image content
contours IOutputArray: Detected contours. Each contour is stored as a vector of points.
hierarchy IOutputArray: Optional output vector, containing information about the image topology.
mode RetrType: Retrieval mode
method ChainApproxMethod: Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
offset Point: 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

FindEssentialMat(IInputArray, IInputArray, IInputArray, FmType, double, double, IOutputArray)

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

public static Mat FindEssentialMat(IInputArray points1, IInputArray points2, IInputArray cameraMatrix, FmType method = FmType.Ransac, double prob = 0.999, double threshold = 1, IOutputArray mask = null)

Parameters

points1 IInputArray: Array of N (N >= 5) 2D points from the first image. The point coordinates should be floating-point (single or double precision).
points2 IInputArray: Array of the second image points of the same size and format as points1
cameraMatrix IInputArray: Camera matrix K=[[fx 0 cx][0 fy cy][0 0 1]]. Note that this function assumes that points1 and points2 are feature points from cameras with the same camera matrix.
method FmType: Method for computing a fundamental matrix. RANSAC for the RANSAC algorithm. LMEDS for the LMedS algorithm
prob double: Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
threshold 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.
mask IOutputArray: 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.

Returns

Mat: The essential mat

FindFundamentalMat(IInputArray, IInputArray, FmType, double, double, IOutputArray)

Calculates fundamental matrix using one of four methods listed above and returns the number of fundamental matrices found (1 or 3) and 0, if no matrix is found.

public static Mat FindFundamentalMat(IInputArray points1, IInputArray points2, FmType method = FmType.Ransac, double param1 = 3, double param2 = 0.99, IOutputArray mask = null)

Parameters

points1 IInputArray: Array of N points from the first image. The point coordinates should be floating-point (single or double precision).
points2 IInputArray: Array of the second image points of the same size and format as points1
method FmType: Method for computing the 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 IOutputArray: The optional pointer to output array of N elements, every element of which is set to 0 for outliers and to 1 for the "inliers", i.e. points that comply well with the estimated epipolar geometry. The array is computed only in RANSAC and LMedS methods. For other methods it is set to all 1.

Returns

Mat: The calculated fundamental matrix

FindHomography(IInputArray, IInputArray, RobustEstimationAlgorithm, double, IOutputArray)

Finds perspective transformation H=||hij|| between the source and the destination planes

public static Mat FindHomography(IInputArray srcPoints, IInputArray dstPoints, RobustEstimationAlgorithm method = RobustEstimationAlgorithm.AllPoints, double ransacReprojThreshold = 3, IOutputArray mask = null)

Parameters

srcPoints IInputArray: Point coordinates in the original plane, 2xN, Nx2, 3xN or Nx3 array (the latter two are for representation in homogeneous coordinates), where N is the number of points.
dstPoints IInputArray: Point coordinates in the destination plane, 2xN, Nx2, 3xN or Nx3 array (the latter two are for representation in homogeneous coordinates)
method RobustEstimationAlgorithm: The type of the method
ransacReprojThreshold double: The maximum allowed re-projection error to treat a point pair as an inlier. The parameter is only used in RANSAC-based homography estimation. E.g. if dst_points coordinates are measured in pixels with pixel-accurate precision, it makes sense to set this parameter somewhere in the range ~1..3
mask IOutputArray: The optional output mask set by a robust method (RANSAC or LMEDS).

Returns

Mat: Output 3x3 homography matrix. Homography matrix is determined up to a scale, thus it is normalized to make h33=1

FindHomography(PointF[], PointF[], RobustEstimationAlgorithm, double, IOutputArray)

Finds perspective transformation H=||h_ij|| between the source and the destination planes

public static Mat FindHomography(PointF[] srcPoints, PointF[] dstPoints, RobustEstimationAlgorithm method = RobustEstimationAlgorithm.AllPoints, double ransacReprojThreshold = 3, IOutputArray mask = null)

Parameters

srcPoints PointF[]: Point coordinates in the original plane
dstPoints PointF[]: Point coordinates in the destination plane
method RobustEstimationAlgorithm: FindHomography method
ransacReprojThreshold double: The maximum allowed reprojection error to treat a point pair as an inlier. The parameter is only used in RANSAC-based homography estimation. E.g. if dst_points coordinates are measured in pixels with pixel-accurate precision, it makes sense to set this parameter somewhere in the range ~1..3
mask IOutputArray: Optional output mask set by a robust method ( CV_RANSAC or CV_LMEDS ). Note that the input mask values are ignored.

Returns

Mat: The 3x3 homography matrix if found. Null if not found.

FindNonZero(IInputArray, IOutputArray)

Find the location of the non-zero pixel

public static void FindNonZero(IInputArray src, IOutputArray idx)

Parameters

src IInputArray: The source array
idx IOutputArray: The output array where the location of the pixels are sorted

FindTransformECC(IInputArray, IInputArray, IInputOutputArray, MotionType, MCvTermCriteria, IInputArray)

Finds the geometric transform (warp) between two images in terms of the ECC criterion

public static double FindTransformECC(IInputArray templateImage, IInputArray inputImage, IInputOutputArray warpMatrix, MotionType motionType, MCvTermCriteria criteria, IInputArray inputMask = null)

Parameters

templateImage IInputArray: single-channel template image; CV_8U or CV_32F array.
inputImage IInputArray: single-channel input image which should be warped with the final warpMatrix in order to provide an image similar to templateImage, same type as temlateImage.
warpMatrix IInputOutputArray: floating-point 2×3 or 3×3 mapping matrix (warp).
motionType MotionType: Specifying the type of motion. Use Affine for default
criteria MCvTermCriteria: specifying the termination criteria of the ECC algorithm; criteria.epsilon defines the threshold of the increment in the correlation coefficient between two iterations (a negative criteria.epsilon makes criteria.maxcount the only termination criterion). Default values can use 50 iteration and 0.001 eps.
inputMask IInputArray: An optional mask to indicate valid values of inputImage.

Returns

double: The final enhanced correlation coefficient, that is the correlation coefficient between the template image and the final warped input image.

FitEllipse(IInputArray)

Fits an ellipse around a set of 2D points.

public static RotatedRect FitEllipse(IInputArray points)

Parameters

points IInputArray: Input 2D point set

Returns

RotatedRect: The ellipse that fits best (in least-squares sense) to a set of 2D points

FitEllipseAMS(IInputArray)

The function calculates the ellipse that fits a set of 2D points. The Approximate Mean Square (AMS) is used.

public static RotatedRect FitEllipseAMS(IInputArray points)

Parameters

points IInputArray: Input 2D point set

Returns

RotatedRect: The rotated rectangle in which the ellipse is inscribed

FitEllipseDirect(IInputArray)

The function calculates the ellipse that fits a set of 2D points. The Direct least square (Direct) method by [58] is used.

public static RotatedRect FitEllipseDirect(IInputArray points)

Parameters

points IInputArray: Input 2D point set

Returns

RotatedRect: The rotated rectangle in which the ellipse is inscribed

FitLine(IInputArray, IOutputArray, DistType, double, double, double)

Fits line to 2D or 3D point set

public static void FitLine(IInputArray points, IOutputArray line, DistType distType, double param, double reps, double aeps)

Parameters

points IInputArray: Input vector of 2D or 3D points, stored in std::vector or Mat.
line IOutputArray: 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 DistType: The distance used for fitting
param double: Numerical parameter (C) for some types of distances, if 0 then some optimal value is chosen
reps double: Sufficient accuracy for radius (distance between the coordinate origin and the line), 0.01 would be a good default
aeps double: Sufficient accuracy for angle, 0.01 would be a good default

FitLine(PointF[], out PointF, out PointF, DistType, double, double, double)

Fits line to 2D or 3D point set

public static void FitLine(PointF[] points, out PointF direction, out PointF pointOnLine, DistType distType, double param, double reps, double aeps)

Parameters

points PointF[]: Input vector of 2D points.
direction PointF: A normalized vector collinear to the line
pointOnLine PointF: A point on the line.
distType DistType: The distance used for fitting
param double: Numerical parameter (C) for some types of distances, if 0 then some optimal value is chosen
reps double: Sufficient accuracy for radius (distance between the coordinate origin and the line), 0.01 would be a good default
aeps double: Sufficient accuracy for angle, 0.01 would be a good default

Flip(IInputArray, IOutputArray, FlipType)

Flips the array in one of different 3 ways (row and column indices are 0-based)

public static void Flip(IInputArray src, IOutputArray dst, FlipType flipType)

Parameters

src IInputArray: Source array.
dst IOutputArray: Destination array.
flipType FlipType: Specifies how to flip the array.

FlipND(IInputArray, IOutputArray, int)

Flips a n-dimensional at given axis

public static void FlipND(IInputArray src, IOutputArray dst, int axis)

Parameters

src IInputArray: Input array
dst IOutputArray: Output array that has the same shape of src
axis int: Axis that performs a flip on. 0 <= axis < src.dims.

FloodFill(IInputOutputArray, IInputOutputArray, Point, MCvScalar, out Rectangle, MCvScalar, MCvScalar, Connectivity, FloodFillType)

Fills a connected component with given color.

public static int FloodFill(IInputOutputArray src, IInputOutputArray mask, Point seedPoint, MCvScalar newVal, out Rectangle rect, MCvScalar loDiff, MCvScalar upDiff, Connectivity connectivity = Connectivity.FourConnected, FloodFillType flags = FloodFillType.Default)

Parameters

src IInputOutputArray: Input 1- or 3-channel, 8-bit or floating-point image. It is modified by the function unless CV_FLOODFILL_MASK_ONLY flag is set.
mask IInputOutputArray: Operation mask, should be singe-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. If not IntPtr.Zero, the function uses and updates the mask, so user takes responsibility of initializing mask content. Floodfilling can't 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. Or it is possible to use the same mask in multiple calls to the function to make sure the filled area do not overlap. Note: because mask is larger than the filled image, pixel in mask that corresponds to (x,y) pixel in image will have coordinates (x+1,y+1).
seedPoint Point: The starting point.
newVal MCvScalar: New value of repainted domain pixels.
rect Rectangle: Output parameter set by the function to the minimum bounding rectangle of the repainted domain.
loDiff MCvScalar: Maximal lower brightness/color difference between the currently observed pixel and one of its neighbor belong to the component or seed pixel to add the pixel to component. In case of 8-bit color images it is packed value.
upDiff MCvScalar: Maximal upper brightness/color difference between the currently observed pixel and one of its neighbor belong to the component or seed pixel to add the pixel to component. In case of 8-bit color images it is packed value.
connectivity Connectivity: Flood fill connectivity
flags FloodFillType: The operation flags.

Returns

int: The area of the connected component

GaussianBlur(IInputArray, IOutputArray, Size, double, double, BorderType)

Blurs an image using a Gaussian filter.

public static void GaussianBlur(IInputArray src, IOutputArray dst, Size ksize, double sigmaX, double sigmaY = 0, BorderType borderType = BorderType.Default)

Parameters

src IInputArray: 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 IOutputArray: 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 BorderType: Pixel extrapolation method

Gemm(IInputArray, IInputArray, double, IInputArray, double, IOutputArray, GemmType)

Performs generalized matrix multiplication: dst = alpha*op(src1)op(src2) + betaop(src3), where op(X) is X or XT

public static void Gemm(IInputArray src1, IInputArray src2, double alpha, IInputArray src3, double beta, IOutputArray dst, GemmType tAbc = GemmType.Default)

Parameters

src1 IInputArray: The first source array.
src2 IInputArray: The second source array.
alpha double: The scalar
src3 IInputArray: The third source array (shift). Can be null, if there is no shift.
beta double: The scalar
dst IOutputArray: The destination array.
tAbc GemmType: The Gemm operation type

GetAffineTransform(IInputArray, IOutputArray)

Calculates the matrix of an affine transform such that: (x'_i,y'_i)^T=map_matrix (x_i,y_i,1)^T where dst(i)=(x'_i,y'_i), src(i)=(x_i,y_i), i=0..2.

public static Mat GetAffineTransform(IInputArray src, IOutputArray dst)

Parameters

src IInputArray: Pointer to an array of PointF, Coordinates of 3 triangle vertices in the source image.
dst IOutputArray: Pointer to an array of PointF, Coordinates of the 3 corresponding triangle vertices in the destination image

Returns

Mat: The destination 2x3 matrix

GetAffineTransform(PointF[], PointF[])

Calculates the matrix of an affine transform such that: (x'_i,y'_i)^T=map_matrix (x_i,y_i,1)^T where dst(i)=(x'_i,y'_i), src(i)=(x_i,y_i), i=0..2.

public static Mat GetAffineTransform(PointF[] src, PointF[] dest)

Parameters

src PointF[]: Coordinates of 3 triangle vertices in the source image. If the array contains more than 3 points, only the first 3 will be used
dest PointF[]: Coordinates of the 3 corresponding triangle vertices in the destination image. If the array contains more than 3 points, only the first 3 will be used

Returns

Mat: The 2x3 rotation matrix that defines the Affine transform

GetCvStructSizes()

This function retrieve the Open CV structure sizes in unmanaged code

public static CvStructSizes GetCvStructSizes()

Returns

CvStructSizes: The structure that will hold the Open CV structure sizes

GetDefaultNewCameraMatrix(IInputArray, Size, bool)

Returns the default new camera matrix.

public static Mat GetDefaultNewCameraMatrix(IInputArray cameraMatrix, Size imgsize = default, bool centerPrincipalPoint = false)

Parameters

cameraMatrix IInputArray: 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.

Returns

Mat: The default new camera matrix.

GetDepthType(DepthType)

Get the corresponding depth type

public static Type GetDepthType(DepthType t)

Parameters

t DepthType: The opencv depth type

Returns

Type: The equivalent depth type

GetDepthType(Type)

Get the corresponding opencv depth type

public static DepthType GetDepthType(Type t)

Parameters

t Type: The element type

Returns

DepthType: The equivalent opencv depth type

GetDerivKernels(IOutputArray, IOutputArray, int, int, int, bool, DepthType)

Returns filter coefficients for computing spatial image derivatives.

public static void GetDerivKernels(IOutputArray kx, IOutputArray ky, int dx, int dy, int ksize, bool normalize = false, DepthType ktype = DepthType.Cv32F)

Parameters

kx IOutputArray: Output matrix of row filter coefficients.
ky IOutputArray: Output matrix of column filter coefficients.
dx int: Derivative order in respect of x.
dy int: Derivative order in respect of y.
ksize int: Aperture size. It can be FILTER_SCHARR, 1, 3, 5, or 7.
normalize bool: Flag indicating whether to normalize (scale down) the filter coefficients or not.
ktype DepthType: Type of filter coefficients. It can be CV_32f or CV_64F .

GetErrMode()

Returns the current error mode

public static extern int GetErrMode()

Returns

int: The error mode

GetErrStatus()

Returns the current error status - the value set with the last cvSetErrStatus call. Note, that in Leaf mode the program terminates immediately after error occurred, so to always get control after the function call, one should call cvSetErrMode and set Parent or Silent error mode.

public static extern int GetErrStatus()

Returns

int: The current error status

GetGaborKernel(Size, double, double, double, double, double, DepthType)

Returns Gabor filter coefficients.

public static Mat GetGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = 1.5707963267948966, DepthType ktype = DepthType.Cv64F)

Parameters

ksize Size: Size of the filter returned.
sigma double: Standard deviation of the gaussian envelope.
theta double: Orientation of the normal to the parallel stripes of a Gabor function.
lambd double: Wavelength of the sinusoidal factor.
gamma double: Spatial aspect ratio.
psi double: Phase offset.
ktype DepthType: Type of filter coefficients. It can be CV_32F or CV_64F .

Returns

Mat: Gabor filter coefficients.

GetGaussianKernel(int, double, DepthType)

Returns Gaussian filter coefficients.

public static Mat GetGaussianKernel(int ksize, double sigma, DepthType ktype = DepthType.Cv64F)

Parameters

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.
ktype DepthType: Type of filter coefficients. It can be CV_32F or CV_64F

Returns

Mat: Gaussian filter coefficients.

GetModuleFormatString()

Get the module format string.

public static string GetModuleFormatString()

Returns

string: On Windows, "{0}".dll will be returned; On Linux, "lib{0}.so" will be returned; Otherwise {0} is returned.

GetOptimalDFTSize(int)

Returns the minimum number N that is greater to equal to size0, such that DFT of a vector of size N can be computed fast. In the current implementation N=2^p x 3^q x 5^r for some p, q, r.

public static int GetOptimalDFTSize(int vecsize)

Parameters

vecsize int: Vector size

Returns

int: The minimum number N that is greater to equal to size0, such that DFT of a vector of size N can be computed fast. In the current implementation N=2^p x 3^q x 5^r for some p, q, r.

GetOptimalNewCameraMatrix(IInputArray, IInputArray, Size, double, Size, ref Rectangle, bool)

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

public static Mat GetOptimalNewCameraMatrix(IInputArray cameraMatrix, IInputArray distCoeffs, Size imageSize, double alpha, Size newImgSize, ref Rectangle validPixROI, bool centerPrincipalPoint = false)

Parameters

cameraMatrix IInputArray: Input camera matrix.
distCoeffs IInputArray: Input vector of distortion coefficients (k1,k2,p1,p2[,k3[,k4,k5,k6[,s1,s2,s3,s4[,?x,?y]]]]) of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, 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 Rectangle: output rectangle that outlines all-good-pixels region in the undistorted image.
centerPrincipalPoint bool: 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.

Returns

Mat: The new camera matrix based on the free scaling parameter.

GetPerspectiveTransform(IInputArray, IInputArray)

calculates matrix of perspective transform such that: (t_i x'_i,t_i y'_i,t_i)^T=map_matrix (x_i,y_i,1)T where dst(i)=(x'_i,y'_i), src(i)=(x_i,y_i), i=0..3.

public static Mat GetPerspectiveTransform(IInputArray src, IInputArray dst)

Parameters

src IInputArray: Coordinates of 4 quadrangle vertices in the source image
dst IInputArray: Coordinates of the 4 corresponding quadrangle vertices in the destination image

Returns

Mat: The perspective transform matrix

GetPerspectiveTransform(PointF[], PointF[])

calculates matrix of perspective transform such that: (t_i x'_i,t_i y'_i,t_i)^T=map_matrix (x_i,y_i,1)^T where dst(i)=(x'_i,y'_i), src(i)=(x_i,y_i), i=0..3.

public static Mat GetPerspectiveTransform(PointF[] src, PointF[] dest)

Parameters

src PointF[]: Coordinates of 4 quadrangle vertices in the source image
dest PointF[]: Coordinates of the 4 corresponding quadrangle vertices in the destination image

Returns

Mat: The 3x3 Homography matrix

GetRectSubPix(IInputArray, Size, PointF, IOutputArray, DepthType)

Extracts pixels from src: dst(x, y) = src(x + center.x - (width(dst)-1)*0.5, y + center.y - (height(dst)-1)*0.5) where the values of pixels at non-integer coordinates are retrieved using bilinear interpolation. Every channel of multiple-channel images is processed independently. Whereas the rectangle center must be inside the image, the whole rectangle may be partially occluded. In this case, the replication border mode is used to get pixel values beyond the image boundaries.

public static void GetRectSubPix(IInputArray image, Size patchSize, PointF center, IOutputArray patch, DepthType patchType = DepthType.Default)

Parameters

image IInputArray: Source image
patchSize Size: Size of the extracted patch.
center PointF: Floating point coordinates of the extracted rectangle center within the source image. The center must be inside the image.
patch IOutputArray: Extracted rectangle
patchType DepthType: Depth of the extracted pixels. By default, they have the same depth as image.

GetRotationMatrix2D(PointF, double, double, IOutputArray)

Calculates rotation matrix

public static void GetRotationMatrix2D(PointF center, double angle, double scale, IOutputArray mapMatrix)

Parameters

center PointF: Center of the rotation in the source image.
angle double: The rotation angle in degrees. Positive values mean couter-clockwise rotation (the coordiate origin is assumed at top-left corner).
scale double: Isotropic scale factor
mapMatrix IOutputArray: Pointer to the destination 2x3 matrix

GetStructuringElement(ElementShape, Size, Point)

Returns a structuring element of the specified size and shape for morphological operations.

public static Mat GetStructuringElement(ElementShape shape, Size ksize, Point anchor)

Parameters

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

Returns

Mat: The structuring element

GetTextSize(string, FontFace, double, int, ref int)

Calculates the width and height of a text string.

public static Size GetTextSize(string text, FontFace fontFace, double fontScale, int thickness, ref int baseLine)

Parameters

text string: Input text string.
fontFace FontFace: Font to use
fontScale double: Font scale factor that is multiplied by the font-specific base size.
thickness int: Thickness of lines used to render the text.
baseLine int: Y-coordinate of the baseline relative to the bottom-most text point.

Returns

Size: The size of a box that contains the specified text.

GetWindowProperty(string, WindowPropertyFlags)

Provides parameters of a window.

public static double GetWindowProperty(string name, WindowPropertyFlags propId)

Parameters

name string: Name of the window.
propId WindowPropertyFlags: Window property to retrieve.

Returns

double: Value of the window property

GrabCut(IInputArray, IInputOutputArray, Rectangle, IInputOutputArray, IInputOutputArray, int, GrabcutInitType)

The grab cut algorithm for segmentation

public static void GrabCut(IInputArray img, IInputOutputArray mask, Rectangle rect, IInputOutputArray bgdModel, IInputOutputArray fgdModel, int iterCount, GrabcutInitType type)