Click or drag to resize
CvInvoke Class
http://www.emgu.com
Library to invoke OpenCV functions
Inheritance Hierarchy
SystemObject
  Emgu.CVCvInvoke

Namespace: Emgu.CV
Assembly: Emgu.CV (in Emgu.CV.dll) Version: 3.0.0.2161 (3.0.0.2161)
Syntax
public static class CvInvoke

The CvInvoke type exposes the following members.

Methods
  NameDescription
Public methodStatic memberAbsDiff
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 methodStatic memberAccumulate
Adds the whole image or its selected region to accumulator sum
Public methodStatic memberAccumulateProduct
Adds product of 2 images or thier selected regions to accumulator acc
Public methodStatic memberAccumulateSquare
Adds the input src or its selected region, raised to power 2, to the accumulator sqsum
Public methodStatic memberAccumulateWeighted
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 methodStatic memberAdaptiveThreshold
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 methodStatic memberAdd
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 methodStatic memberAddWeighted
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 methodStatic memberApplyColorMap
Apply color map to the image
Public methodStatic memberApproxPolyDP
Approximates a polygonal curve(s) with the specified precision.
Public methodStatic memberArcLength
Calculates a contour perimeter or a curve length
Public methodStatic memberArrowedLine
Draws a arrow segment pointing from the first point to the second one.
Public methodStatic memberBalanceWhite
The function implements different algorithm of automatic white balance, i.e. it tries to map image’s white color to perceptual white (this can be violated due to specific illumination or camera settings).
Public methodStatic memberBilateralFilter
Applies the bilateral filter to an image.
Public methodStatic memberBitwiseAnd
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 methodStatic memberBitwiseNot
Inverses every bit of every array element:
Public methodStatic memberBitwiseOr
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 methodStatic memberBitwiseXor
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 methodStatic memberBlur
Blurs an image using the normalized box filter.
Public methodStatic memberBoundingRectangle
Returns the up-right bounding rectangle for 2d point set
Public methodStatic memberBoxFilter
Blurs an image using the box filter.
Public methodStatic memberBoxPoints(RotatedRect)
Calculates vertices of the input 2d box.
Public methodStatic memberBoxPoints(RotatedRect, IOutputArray)
Calculates vertices of the input 2d box.
Public methodStatic memberCalcBackProject
Calculates the back projection of a histogram.
Public methodStatic memberCalcCovarMatrix
Calculates the covariance matrix of a set of vectors.
Public methodStatic memberCalcGlobalOrientation
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 methodStatic memberCalcHist
Calculates a histogram of a set of arrays.
Public methodStatic memberCalcMotionGradient
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 methodStatic memberCalcOpticalFlowFarneback(IInputArray, IInputArray, IInputOutputArray, Double, Int32, Int32, Int32, Int32, Double, OpticalflowFarnebackFlag)
Computes dense optical flow using Gunnar Farneback's algorithm
Public methodStatic memberCalcOpticalFlowFarneback(ImageGray, Byte, ImageGray, Byte, ImageGray, Single, ImageGray, Single, Double, Int32, Int32, Int32, Int32, Double, OpticalflowFarnebackFlag)
Computes dense optical flow using Gunnar Farneback's algorithm
Public methodStatic memberCalcOpticalFlowPyrLK(IInputArray, IInputArray, IInputArray, IInputOutputArray, IOutputArray, IOutputArray, Size, Int32, 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 methodStatic memberCalcOpticalFlowPyrLK(IInputArray, IInputArray, PointF, Size, Int32, MCvTermCriteria, PointF, Byte, Single, LKFlowFlag, Double)
Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in pyramids
Public methodStatic memberCalibrateCamera(IInputArray, IInputArray, Size, IInputOutputArray, IInputOutputArray, IOutputArray, IOutputArray, CalibType, MCvTermCriteria)
Estimates intrinsic camera parameters and extrinsic parameters for each of the views
Public methodStatic memberCalibrateCamera(MCvPoint3D32f, PointF, Size, IInputOutputArray, IInputOutputArray, CalibType, MCvTermCriteria, Mat, Mat)
Estimates intrinsic camera parameters and extrinsic parameters for each of the views
Public methodStatic memberCalibrationMatrixValues
Computes various useful camera (sensor/lens) characteristics using the computed camera calibration matrix, image frame resolution in pixels and the physical aperture size
Public methodStatic memberCamShift
Implements CAMSHIFT object tracking algorithm ([Bradski98]). First, it finds an object center using cvMeanShift and, after that, calculates the object size and orientation.
Public methodStatic memberCanny
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 methodStatic memberCartToPolar
Calculates either magnitude, angle, or both of every 2d vector (x(I),y(I)): magnitude(I)=sqrt( x(I)2+y(I)2 ), angle(I)=atan( y(I)/x(I) ) The angles are calculated with ~0.1 degree accuracy. For (0,0) point the angle is set to 0
Public methodStatic memberCheckLibraryLoaded
Check to make sure all the unmanaged libraries are loaded
Public methodStatic memberCheckRange
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 methodStatic memberCircle
Draws a simple or filled circle with given center and radius. The circle is clipped by ROI rectangle.
Public methodStatic memberCLAHE
Contrast Limited Adaptive Histogram Equalization (CLAHE)
Public methodStatic memberClipLine
Calculates a part of the line segment which is entirely in the rectangle.
Public methodStatic memberColorChange
Given an original color image, two differently colored versions of this image can be mixed seamlessly.
Public methodStatic memberCompare
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 methodStatic memberCompareHist
Compares two histograms.
Public methodStatic memberComputeCorrespondEpilines
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 a*x + b*y + 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=F*p1 and the line l1 for a point p2 in the second image (which_image=1) can be computed as: l1=F^T*p2Line coefficients are defined up to a scale. They are normalized (a2+b2=1) are stored into correspondent_lines
Public methodStatic memberContourArea
Calculates area of the whole contour or contour section.
Public methodStatic memberConvertMaps
Converts image transformation maps from one representation to another.
Public methodStatic memberConvertPointsFromHomogeneous
Converts points from homogeneous to Euclidean space.
Public methodStatic memberConvertPointsToHomogeneous
Converts points from Euclidean to homogeneous space.
Public methodStatic memberConvertScaleAbs
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 methodStatic memberConvexHull(PointF, Boolean)
Finds convex hull of 2D point set using Sklansky's algorithm
Public methodStatic memberConvexHull(IInputArray, IOutputArray, Boolean, Boolean)
The function cvConvexHull2 finds convex hull of 2D point set using Sklansky's algorithm.
Public methodStatic memberConvexityDefects
Finds the convexity defects of a contour.
Public methodStatic memberCopyMakeBorder
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 methodStatic memberCornerHarris
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 methodStatic memberCornerSubPix
Iterates to find the sub-pixel accurate location of corners, or radial saddle points
Public methodStatic memberCorrectMatches
Refines coordinates of corresponding points.
Public methodStatic memberCountNonZero
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 methodStatic memberCreateHanningWindow
This function computes a Hanning window coefficients in two dimensions.
Public methodStatic memberCvArrToMat
Converts CvMat, IplImage , or CvMatND to Mat.
Public methodStatic membercvCheckArr
Checks that every array element is neither NaN nor Infinity. If CV_CHECK_RANGE is set, it also checks that every element is greater than or equal to minVal and less than maxVal.
Public methodStatic membercvClearND
Clears (sets to zero) the particular element of dense array or deletes the element of sparse array. If the element does not exists, the function does nothing
Public methodStatic membercvConvertScale
This function has several different purposes and thus has several synonyms. It copies one array to another with optional scaling, which is performed first, and/or optional type conversion, performed after: dst(I)=src(I)*scale + (shift,shift,...) All the channels of multi-channel arrays are processed independently. The type conversion is done with rounding and saturation, that is if a result of scaling + conversion can not be represented exactly by a value of destination array element type, it is set to the nearest representable value on the real axis. In case of scale=1, shift=0 no prescaling is done. This is a specially optimized case and it has the appropriate cvConvert synonym. If source and destination array types have equal types, this is also a special case that can be used to scale and shift a matrix or an image and that fits to cvScale synonym.
Public methodStatic membercvCopy
Copies selected elements from input array to output array: dst(I)=src(I) if mask(I)!=0. If any of the passed arrays is of IplImage type, then its ROI and COI fields are used. Both arrays must have the same type, the same number of dimensions and the same size. The function can also copy sparse arrays (mask is not supported in this case).
Public methodStatic membercvCreateImage
Creates the header and allocates data.
Public methodStatic membercvCreateImageHeader
Allocates, initializes, and returns the structure IplImage.
Public methodStatic membercvCreateMat
Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix. Matrices are stored row by row. All the rows are aligned by 4 bytes.
Public methodStatic membercvCreateSparseMat
The function allocates a multi-dimensional sparse array. Initially the array contain no elements, that is Get or GetReal returns zero for every index
Public methodStatic membercveVideoCaptureGet
Retrieves the specified property of camera or video file
Public methodStatic membercveVideoCaptureSet
Sets the specified property of video capturing
Public methodStatic membercvGet1D
Return the particular array element
Public methodStatic membercvGet2D
Return the particular array element
Public methodStatic membercvGet3D
Return the particular array element
Public methodStatic membercvGetCentralMoment
Retrieves the central moment, which in case of image moments is defined as: mu_{x_order,y_order}=sum_{x,y}(I(x,y)*(x-x_c)^{x_order} * (y-y_c)^{y_order}), where x_c=M10/M00, y_c=M01/M00 - coordinates of the gravity center
Public methodStatic membercvGetCol
Return the header, corresponding to a specified column of the input array
Public methodStatic membercvGetCols
Return the header, corresponding to a specified col span of the input array
Public methodStatic membercvGetDiag
returns the header, corresponding to a specified diagonal of the input array
Public methodStatic membercvGetImage
Returns image header for the input array that can be matrix - CvMat*, or image - IplImage*.
Public methodStatic membercvGetImageCOI
Returns channel of interest of the image (it returns 0 if all the channels are selected).
Public methodStatic membercvGetImageROI
Returns channel of interest of the image (it returns 0 if all the channels are selected).
Public methodStatic membercvGetMat
Returns matrix header for the input array that can be matrix - CvMat, image - IplImage or multi-dimensional dense array - CvMatND* (latter case is allowed only if allowND != 0) . In the case of matrix the function simply returns the input pointer. In the case of IplImage* or CvMatND* it initializes header structure with parameters of the current image ROI and returns pointer to this temporary structure. Because COI is not supported by CvMat, it is returned separately.
Public methodStatic membercvGetNormalizedCentralMoment
Retrieves normalized central moment, which in case of image moments is defined as: eta_{x_order,y_order}=mu_{x_order,y_order} / M00^{(y_order+x_order)/2+1}, where mu_{x_order,y_order} is the central moment
Public methodStatic membercvGetRawData
Fills output variables with low-level information about the array data. All output parameters are optional, so some of the pointers may be set to NULL. If the array is IplImage with ROI set, parameters of ROI are returned.
Public methodStatic membercvGetReal1D
Return the particular element of single-channel array. If the array has multiple channels, runtime error is raised. Note that cvGet*D function can be used safely for both single-channel and multiple-channel arrays though they are a bit slower.
Public methodStatic membercvGetReal2D
Return the particular element of single-channel array. If the array has multiple channels, runtime error is raised. Note that cvGet*D function can be used safely for both single-channel and multiple-channel arrays though they are a bit slower.
Public methodStatic membercvGetReal3D
Return the particular element of single-channel array. If the array has multiple channels, runtime error is raised. Note that cvGet*D function can be used safely for both single-channel and multiple-channel arrays though they are a bit slower.
Public methodStatic membercvGetRow
Return the header, corresponding to a specified row of the input array
Public methodStatic membercvGetRows
Return the header, corresponding to a specified row span of the input array
Public methodStatic membercvGetSize
Returns number of rows (CvSize::height) and number of columns (CvSize::width) of the input matrix or image. In case of image the size of ROI is returned.
Public methodStatic membercvGetSpatialMoment
Retrieves the spatial moment, which in case of image moments is defined as: M_{x_order,y_order}=sum_{x,y}(I(x,y) * x^{x_order} * y^{y_order}) where I(x,y) is the intensity of the pixel (x, y).
Public methodStatic membercvGetSubRect
Returns header, corresponding to a specified rectangle of the input array. In other words, it allows the user to treat a rectangular part of input array as a stand-alone array. ROI is taken into account by the function so the sub-array of ROI is actually extracted.
Public methodStatic membercvInitImageHeader
Initializes the image header structure, pointer to which is passed by the user, and returns the pointer.
Public methodStatic membercvInitMatHeader
Initializes already allocated CvMat structure. It can be used to process raw data with OpenCV matrix functions.
Public methodStatic membercvInitMatNDHeader
Initializes CvMatND structure allocated by the user
Public methodStatic membercvMaxRect
Finds minimum area rectangle that contains both input rectangles inside
Public methodStatic membercvRange
Initializes the matrix as following: arr(i,j)=(end-start)*(i*cols(arr)+j)/(cols(arr)*rows(arr))
Public methodStatic membercvReleaseImage
Releases the header and the image data.
Public methodStatic membercvReleaseImageHeader
Releases the header.
Public methodStatic membercvReleaseMat
Decrements the matrix data reference counter and releases matrix header
Public methodStatic membercvReleaseSparseMat
The function releases the sparse array and clears the array pointer upon exit.
Public methodStatic membercvResetImageROI
Releases image ROI. After that the whole image is considered selected.
Public methodStatic membercvReshape
initializes CvMat header so that it points to the same data as the original array but has different shape - different number of channels, different number of rows or both
Public methodStatic membercvSampleLine
Implements a particular case of application of line iterators. The function reads all the image points lying on the line between pt1 and pt2, including the ending points, and stores them into the buffer
Public methodStatic membercvSet2D
Assign the new value to the particular element of array
Public methodStatic membercvSetData
Assigns user data to the array header.
Public methodStatic membercvSetImageCOI
Sets the channel of interest to a given value. Value 0 means that all channels are selected, 1 means that the first channel is selected etc. If ROI is NULL and coi != 0, ROI is allocated.
Public methodStatic membercvSetImageROI
Sets the image ROI to a given rectangle. If ROI is NULL and the value of the parameter rect is not equal to the whole image, ROI is allocated.
Public methodStatic membercvSetReal1D
Assign the new value to the particular element of single-channel array
Public methodStatic membercvSetReal2D
Assign the new value to the particular element of single-channel array
Public methodStatic membercvSetReal3D
Assign the new value to the particular element of single-channel array
Public methodStatic membercvSetRealND
Assign the new value to the particular element of single-channel array
Public methodStatic memberCvtColor(IInputArray, IOutputArray, ColorConversion, Int32)
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 methodStatic memberCvtColor(IInputArray, IOutputArray, Type, Type)
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 methodStatic memberDct
Performs forward or inverse transform of 1D or 2D floating-point array
Public methodStatic memberDctDenoising
The function implements simple dct-based denoising, link: http://www.ipol.im/pub/art/2011/ys-dct/.
Public methodStatic memberDefaultLoadUnmanagedModules
Attempts to load opencv modules from the specific location
Public methodStatic memberDenoiseTVL1
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 methodStatic memberDestroyAllWindows
Destroys all of the HighGUI windows.
Public methodStatic memberDestroyWindow
Destroys the window with a given name
Public methodStatic memberDetailEnhance
This filter enhances the details of a particular image.
Public methodStatic memberDeterminant
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 methodStatic memberDft
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 methodStatic memberDilate
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 methodStatic memberDistanceTransform
Calculates distance to closest zero pixel for all non-zero pixels of source image
Public methodStatic memberDivide
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 methodStatic memberDrawChessboardCorners
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 methodStatic memberDrawContours
Draws contours outlines or filled contours.
Public methodStatic memberEdgePreservingFilter
Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications.
Public methodStatic memberCode exampleEigen
Computes eigenvalues and eigenvectors of a symmetric matrix
Public methodStatic memberEllipse(IInputOutputArray, RotatedRect, MCvScalar, Int32, LineType, Int32)
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 methodStatic memberEllipse(IInputOutputArray, Point, Size, Double, Double, Double, MCvScalar, Int32, LineType, Int32)
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 methodStatic memberEMD
Computes the 'minimal work' distance between two weighted point configurations.
Public methodStatic memberEqualizeHist
The algorithm normalizes brightness and increases contrast of the image
Public methodStatic memberErode
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 methodStatic memberErrorStr
Returns the textual description for the specified error status code. In case of unknown status the function returns NULL pointer.
Public methodStatic memberEstimateAffine3D(IInputArray, IInputArray, IOutputArray, IOutputArray, Double, Double)
Computes an optimal affine transformation between two 3D point sets.
Public methodStatic memberEstimateAffine3D(MCvPoint3D32f, MCvPoint3D32f, MatrixDouble, Byte, Double, Double)
Computes an optimal affine transformation between two 3D point sets.
Public methodStatic memberEstimateRigidTransform(PointF, PointF, Boolean)
Estimate rigid transformation between 2 point sets.
Public methodStatic memberEstimateRigidTransform(IInputArray, IInputArray, Boolean)
Estimate rigid transformation between 2 images or 2 point sets.
Public methodStatic memberExp
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 methodStatic memberExtractChannel
Extract the specific channel from the image
Public methodStatic memberFastNlMeansDenoising
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 methodStatic memberFastNlMeansDenoisingColored
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 methodStatic memberFillConvexPoly
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 methodStatic memberFillPoly
Fills the area bounded by one or more polygons.
Public methodStatic memberFilter2D
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 methodStatic memberFindChessboardCorners
Attempts to determine whether the input image is a view of the chessboard pattern and locate internal chessboard corners
Public methodStatic memberFindCirclesGrid(ImageGray, Byte, Size, CalibCgType, Feature2D)
Finds centers in the grid of circles
Public methodStatic memberFindCirclesGrid(IInputArray, Size, IOutputArray, CalibCgType, Feature2D)
Finds centers in the grid of circles
Public methodStatic memberFindContours
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 methodStatic memberFindContourTree
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 methodStatic memberFindFundamentalMat
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 methodStatic memberFindHomography(PointF, PointF, IOutputArray, HomographyMethod, Double, IOutputArray)
Finds perspective transformation H=||h_ij|| between the source and the destination planes
Public methodStatic memberFindHomography(IInputArray, IInputArray, IOutputArray, HomographyMethod, Double, IOutputArray)
Finds perspective transformation H=||hij|| between the source and the destination planes
Public methodStatic memberFindNonZero
Find the location of the non-zero pixel
Public methodStatic memberFitEllipse
Fits an ellipse around a set of 2D points.
Public methodStatic memberFitLine(IInputArray, IOutputArray, DistType, Double, Double, Double)
Fits line to 2D or 3D point set
Public methodStatic memberFitLine(PointF, PointF, PointF, DistType, Double, Double, Double)
Fits line to 2D or 3D point set
Public methodStatic memberFlip
Flips the array in one of different 3 ways (row and column indices are 0-based)
Public methodStatic memberFloodFill
Fills a connected component with given color.
Public methodStatic memberGaussianBlur
Blurs an image using a Gaussian filter.
Public methodStatic memberGemm
Performs generalized matrix multiplication: dst = alpha*op(src1)*op(src2) + beta*op(src3), where op(X) is X or XT
Public methodStatic memberGetAffineTransform(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 methodStatic memberGetAffineTransform(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 methodStatic memberGetCvStructSizes
This function retrieve the Open CV structure sizes in unmanaged code
Public methodStatic memberGetDefaultNewCameraMatrix
Returns the default new camera matrix.
Public methodStatic memberGetDepthType(Type)
Get the corresponding opencv depth type
Public methodStatic memberGetDepthType(DepthType)
Get the corresponding depth type
Public methodStatic memberGetErrMode
Returns the current error mode
Public methodStatic memberGetErrStatus
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 methodStatic memberGetModuleFormatString
Get the module format string.
Public methodStatic memberGetNumThreads
Return the current number of threads that are used by parallelized (via OpenMP) OpenCV functions.
Public methodStatic memberGetOptimalDFTSize
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 methodStatic memberGetPerspectiveTransform(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 methodStatic memberGetPerspectiveTransform(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 methodStatic memberGetRectSubPix
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 methodStatic memberGetRotationMatrix2D
Calculates rotation matrix
Public methodStatic memberGetStructuringElement
Returns a structuring element of the specified size and shape for morphological operations.
Public methodStatic memberGetThreadNum
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 methodStatic memberGrabCut
The grab cut algorithm for segmentation
Public methodStatic memberHConcat
Horizontally concatenate two images
Public methodStatic memberHoughCircles(IInputArray, HoughType, Double, Double, Double, Double, Int32, Int32)
Finds circles in a grayscale image using the Hough transform
Public methodStatic memberHoughCircles(IInputArray, IOutputArray, HoughType, Double, Double, Double, Double, Int32, Int32)
Finds circles in grayscale image using some modification of Hough transform
Public methodStatic memberHoughLines
Finds lines in a binary image using the standard Hough transform.
Public methodStatic memberHoughLinesP(IInputArray, Double, Double, Int32, Double, Double)
Finds line segments in a binary image using the probabilistic Hough transform.
Public methodStatic memberHoughLinesP(IInputArray, IOutputArray, Double, Double, Int32, Double, Double)
Finds line segments in a binary image using the probabilistic Hough transform.
Public methodStatic memberHuMoments
Calculates seven Hu invariants
Public methodStatic memberIlluminationChange
Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.
Public methodStatic memberImdecode(Byte, LoadImageType, Mat)
Decode image stored in the buffer
Public methodStatic memberImdecode(IInputArray, LoadImageType, Mat)
Decode image stored in the buffer
Public methodStatic memberImencode
encode image and store the result as a byte vector.
Public methodStatic memberImread
Loads an image from the specified file and returns the pointer to the loaded image. Currently the following file formats are supported: Windows bitmaps - BMP, DIB; JPEG files - JPEG, JPG, JPE; Portable Network Graphics - PNG; Portable image format - PBM, PGM, PPM; Sun rasters - SR, RAS; TIFF files - TIFF, TIF; OpenEXR HDR images - EXR; JPEG 2000 images - jp2.
Public methodStatic memberImshow
Shows the image in the specified window
Public methodStatic memberImwrite
Saves the image to the specified file. The image format is chosen depending on the filename extension, see cvLoadImage. Only 8-bit single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function. If the format, depth or channel order is different, use cvCvtScale and cvCvtColor to convert it before saving, or use universal cvSave to save the image to XML or YAML format
Public methodStatic memberInitUndistortRectifyMap
This function is an extended version of cvInitUndistortMap. That is, in addition to the correction of lens distortion, the function can also apply arbitrary perspective transformation R and finally it can scale and shift the image according to the new camera matrix
Public methodStatic memberInpaint
Reconstructs the selected image area from the pixel near the area boundary. The function may be used to remove dust and scratches from a scanned photo, or to remove undesirable objects from still images or video.
Public methodStatic memberInRange
Performs range check for every element of the input array: dst(I)=lower(I)_0 <= src(I)_0 <= upper(I)_0 For single-channel arrays, dst(I)=lower(I)_0 <= src(I)_0 <= upper(I)_0 && lower(I)_1 <= src(I)_1 <= upper(I)_1 For two-channel arrays etc. dst(I) is set to 0xff (all '1'-bits) if src(I) is within the range and 0 otherwise. All the arrays must have the same type, except the destination, and the same size (or ROI size)
Public methodStatic memberInsertChannel
Insert the specific channel to the image
Public methodStatic memberIntegral
Calculates one or more integral images for the source image Using these integral images, one may calculate sum, mean, standard deviation over arbitrary up-right or rotated rectangular region of the image in a constant time. It makes possible to do a fast blurring or fast block correlation with variable window size etc. In case of multi-channel images sums for each channel are accumulated independently.
Public methodStatic memberInvert
Inverts matrix src1 and stores the result in src2
Public methodStatic memberInvertAffineTransform
Inverts an affine transformation
Public methodStatic memberIsContourConvex
The function tests whether the input contour is convex or not. The contour must be simple, that is, without self-intersections. Otherwise, the function output is undefined.
Public methodStatic memberKmeans
Implements k-means algorithm that finds centers of cluster_count clusters and groups the input samples around the clusters. On output labels(i) contains a cluster index for sample stored in the i-th row of samples matrix
Public methodStatic memberLaplacian
Calculates Laplacian of the source image by summing second x- and y- derivatives calculated using Sobel operator: dst(x,y) = d2src/dx2 + d2src/dy2 Specifying aperture_size=1 gives the fastest variant that is equal to convolving the image with the following kernel: |0 1 0| |1 -4 1| |0 1 0| Similar to cvSobel function, no scaling is done and the same combinations of input and output formats are supported.
Public methodStatic memberLine
Draws the line segment between pt1 and pt2 points in the image. The line is clipped by the image or ROI rectangle. For non-antialiased lines with integer coordinates the 8-connected or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings. Antialiased lines are drawn using Gaussian filtering.
Public methodStatic memberLinearPolar
The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
Public methodStatic memberLoadUnmanagedModules
Attempts to load opencv modules from the specific location
Public methodStatic memberLog
Calculates natural logarithm of absolute value of every element of input array: dst(I)=log(abs(src(I))), src(I)!=0 dst(I)=C, src(I)=0 Where C is large negative number (-700 in the current implementation)
Public methodStatic memberLogPolar
The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
Public methodStatic memberLUT
Fills the destination array with values from the look-up table. Indices of the entries are taken from the source array. That is, the function processes each element of src as following: dst(I)=lut[src(I)+DELTA] where DELTA=0 if src has depth CV_8U, and DELTA=128 if src has depth CV_8S
Public methodStatic memberMahalanobis
Calculates the weighted distance between two vectors and returns it
Public methodStatic memberMakeType
This function performs the same as MakeType macro
Public methodStatic memberMatchShapes
Compares two shapes. The 3 implemented methods all use Hu moments
Public methodStatic memberMatchTemplate
This function is similiar to cvCalcBackProjectPatch. It slids through image, compares overlapped patches of size wxh with templ using the specified method and stores the comparison results to result
Public methodStatic memberMax
Calculates per-element maximum of two arrays: dst(I)=max(src1(I), src2(I)) All the arrays must have a single channel, the same data type and the same size (or ROI size).
Public methodStatic memberMean
Calculates the average value M of array elements, independently for each channel: N = sumI mask(I)!=0 Mc = 1/N * sumI,mask(I)!=0 arr(I)c If the array is IplImage and COI is set, the function processes the selected channel only and stores the average to the first scalar component (S0).
Public methodStatic memberMeanShift
Iterates to find the object center given its back projection and initial position of search window. The iterations are made until the search window center moves by less than the given value and/or until the function has done the maximum number of iterations.
Public methodStatic memberMeanStdDev(IInputArray, IOutputArray, IOutputArray, IInputArray)
Calculates a mean and standard deviation of array elements.
Public methodStatic memberMeanStdDev(IInputArray, MCvScalar, MCvScalar, IInputArray)
The function cvAvgSdv calculates the average value and standard deviation of array elements, independently for each channel
Public methodStatic memberMedianBlur
Blurs an image using the median filter.
Public methodStatic memberMerge
This function is the opposite to cvSplit. If the destination array has N channels then if the first N input channels are not IntPtr.Zero, all they are copied to the destination array, otherwise if only a single source channel of the first N is not IntPtr.Zero, this particular channel is copied into the destination array, otherwise an error is raised. Rest of source channels (beyond the first N) must always be IntPtr.Zero. For IplImage cvCopy with COI set can be also used to insert a single channel into the image.
Public methodStatic memberMin
Calculates per-element minimum of two arrays: dst(I)=min(src1(I),src2(I)) All the arrays must have a single channel, the same data type and the same size (or ROI size).
Public methodStatic memberMinAreaRect(PointF)
Find the bounding rectangle for the specific array of points
Public methodStatic memberMinAreaRect(IInputArray)
Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
Public methodStatic memberMinEnclosingCircle(PointF)
Finds the minimal circumscribed circle for 2D point set using iterative algorithm. It returns nonzero if the resultant circle contains all the input points and zero otherwise (i.e. algorithm failed)
Public methodStatic memberMinEnclosingCircle(IInputArray)
Finds the minimal circumscribed circle for 2D point set using iterative algorithm. It returns nonzero if the resultant circle contains all the input points and zero otherwise (i.e. algorithm failed)
Public methodStatic memberMinEnclosingTriangle
Finds a triangle of minimum area enclosing a 2D point set and returns its area.
Public methodStatic memberMinMaxIdx
Finds the global minimum and maximum in an array
Public methodStatic memberMinMaxLoc
Finds minimum and maximum element values and their positions. The extremums are searched over the whole array, selected ROI (in case of IplImage) or, if mask is not IntPtr.Zero, in the specified array region. If the array has more than one channel, it must be IplImage with COI set. In case if multi-dimensional arrays min_loc->x and max_loc->x will contain raw (linear) positions of the extremums
Public methodStatic memberMixChannels
The function cvMixChannels is a generalized form of cvSplit and cvMerge and some forms of cvCvtColor. It can be used to change the order of the planes, add/remove alpha channel, extract or insert a single plane or multiple planes etc.
Public methodStatic memberMoments
Calculates spatial and central moments up to the third order and writes them to moments. The moments may be used then to calculate gravity center of the shape, its area, main axises and various shape characeteristics including 7 Hu invariants.
Public methodStatic memberMorphologyEx
Performs advanced morphological transformations.
Public methodStatic memberMulSpectrums
Performs per-element multiplication of the two CCS-packed or complex matrices that are results of real or complex Fourier transform.
Public methodStatic memberMultiply
Calculates per-element product of two arrays: dst(I)=scale*src1(I)*src2(I) All the arrays must have the same type, and the same size (or ROI size)
Public methodStatic memberMulTransposed
Calculates the product of src and its transposition. The function evaluates dst=scale(src-delta)*(src-delta)^T if order=0, and dst=scale(src-delta)^T*(src-delta) otherwise.
Public methodStatic memberNamedWindow
Creates a window which can be used as a placeholder for images and trackbars. Created windows are reffered by their names. If the window with such a name already exists, the function does nothing.
Public methodStatic memberNorm(IInputArray, NormType, IInputArray)
Returns the calculated norm. The multiple-channel array are treated as single-channel, that is, the results for all channels are combined.
Public methodStatic memberNorm(IInputArray, IInputOutputArray, NormType, IInputArray)
Returns the calculated norm. The multiple-channel array are treated as single-channel, that is, the results for all channels are combined.
Public methodStatic memberNormalize
normalizes the input array so that it's norm or value range takes the certain value(s).
Public methodStatic memberOclFinish
Finishes OpenCL queue.
Public methodStatic memberOclGetPlatformsSummary
Get the OpenCL platform summary as a string
Public methodStatic memberPCABackProject
Reconstructs vectors from their PC projections.
Public methodStatic memberPCACompute(IInputArray, IInputOutputArray, IOutputArray, Double)
Performs Principal Component Analysis of the supplied dataset.
Public methodStatic memberPCACompute(IInputArray, IInputOutputArray, IOutputArray, Int32)
Performs Principal Component Analysis of the supplied dataset.
Public methodStatic memberPCAProject
Projects vector(s) to the principal component subspace.
Public methodStatic memberPencilSketch
Pencil-like non-photorealistic line drawing
Public methodStatic memberPerspectiveTransform(PointF, IInputArray)
Transforms every element of src in the following way: (x, y) -> (x'/w, y'/w), where (x', y', w') = mat3x3 * (x, y, 1) and w = w' if w'!=0, inf otherwise
Public methodStatic memberPerspectiveTransform(IInputArray, IOutputArray, IInputArray)
Transforms every element of src (by treating it as 2D or 3D vector) in the following way: (x, y, z) -> (x'/w, y'/w, z'/w) or (x, y) -> (x'/w, y'/w), where (x', y', z', w') = mat4x4 * (x, y, z, 1) or (x', y', w') = mat3x3 * (x, y, 1) and w = w' if w'!=0, inf otherwise
Public methodStatic memberPhaseCorrelate
The function is used to detect translational shifts that occur between two images. The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation.
Public methodStatic memberPointPolygonTest
Determines whether the point is inside contour, outside, or lies on an edge (or coinsides with a vertex). It returns positive, negative or zero value, correspondingly
Public methodStatic memberPolarToCart
Calculates either x-coordinate, y-coordinate or both of every vector magnitude(I)* exp(angle(I)*j), j=sqrt(-1): x(I)=magnitude(I)*cos(angle(I)), y(I)=magnitude(I)*sin(angle(I))
Public methodStatic memberPolylines(IInputOutputArray, IInputArray, Boolean, MCvScalar, Int32, LineType, Int32)
Draws a single or multiple polygonal curves
Public methodStatic memberPolylines(IInputOutputArray, Point, Boolean, MCvScalar, Int32, LineType, Int32)
Draws a single or multiple polygonal curves
Public methodStatic memberPow
Raises every element of input array to p: dst(I)=src(I)p, if p is integer dst(I)=abs(src(I))p, otherwise That is, for non-integer power exponent the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations, as the following sample, computing cube root of array elements, shows: CvSize size = cvGetSize(src); CvMat* mask = cvCreateMat( size.height, size.width, CV_8UC1 ); cvCmpS( src, 0, mask, CV_CMP_LT ); /* find negative elements */ cvPow( src, dst, 1./3 ); cvSubRS( dst, cvScalarAll(0), dst, mask ); /* negate the results of negative inputs */ cvReleaseMat( &mask ); For some values of power, such as integer values, 0.5 and -0.5, specialized faster algorithms are used.
Public methodStatic memberProjectPoints(MCvPoint3D32f, IInputArray, IInputArray, IInputArray, IInputArray, IOutputArray, Double)
Computes projections of 3D points to the image plane given intrinsic and extrinsic camera parameters. Optionally, the function computes jacobians - matrices of partial derivatives of image points as functions of all the input parameters w.r.t. the particular parameters, intrinsic and/or extrinsic. The jacobians are used during the global optimization in cvCalibrateCamera2 and cvFindExtrinsicCameraParams2. The function itself is also used to compute back-projection error for with current intrinsic and extrinsic parameters.
Public methodStatic memberProjectPoints(IInputArray, IInputArray, IInputArray, IInputArray, IInputArray, IOutputArray, IOutputArray, Double)
Computes projections of 3D points to the image plane given intrinsic and extrinsic camera parameters. Optionally, the function computes jacobians - matrices of partial derivatives of image points as functions of all the input parameters w.r.t. the particular parameters, intrinsic and/or extrinsic. The jacobians are used during the global optimization in cvCalibrateCamera2 and cvFindExtrinsicCameraParams2. The function itself is also used to compute back-projection error for with current intrinsic and extrinsic parameters. Note, that with intrinsic and/or extrinsic parameters set to special values, the function can be used to compute just extrinsic transformation or just intrinsic transformation (i.e. distortion of a sparse set of points).
Public methodStatic memberPSNR
Computes PSNR image/video quality metric
Public methodStatic memberPutText
Renders the text in the image with the specified font and color. The printed text is clipped by ROI rectangle. Symbols that do not belong to the specified font are replaced with the rectangle symbol.
Public methodStatic memberPyrDown
Performs downsampling step of Gaussian pyramid decomposition. First it convolves source image with the specified filter and then downsamples the image by rejecting even rows and columns.
Public methodStatic memberPyrMeanShiftFiltering
Filters image using meanshift algorithm
Public methodStatic memberPyrUp
Performs up-sampling step of Gaussian pyramid decomposition. First it upsamples the source image by injecting even zero rows and columns and then convolves result with the specified filter multiplied by 4 for interpolation. So the destination image is four times larger than the source image.
Public methodStatic memberRandn(IInputOutputArray, IInputArray, IInputArray)
Fills the array with normally distributed random numbers.
Public methodStatic memberRandn(IInputOutputArray, MCvScalar, MCvScalar)
Fills the array with normally distributed random numbers.
Public methodStatic memberRandShuffle
Shuffles the matrix by swapping randomly chosen pairs of the matrix elements on each iteration (where each element may contain several components in case of multi-channel arrays)
Public methodStatic memberRandu(IInputOutputArray, IInputArray, IInputArray)
Generates a single uniformly-distributed random number or an array of random numbers.
Public methodStatic memberRandu(IInputOutputArray, MCvScalar, MCvScalar)
Generates a single uniformly-distributed random number or an array of random numbers.
Public methodStatic memberRawDataToBitmap
Convert raw data to bitmap
Public methodStatic memberRectangle
Draws a rectangle specified by a CvRect structure
Public methodStatic memberRedirectError(IntPtr, IntPtr, IntPtr)
Sets a new error handler that can be one of standard handlers or a custom handler that has the certain interface. The handler takes the same parameters as cvError function. If the handler returns non-zero value, the program is terminated, otherwise, it continues. The error handler may check the current error mode with cvGetErrMode to make a decision.
Public methodStatic memberRedirectError(CvInvokeCvErrorCallback, IntPtr, IntPtr)
Sets a new error handler that can be one of standard handlers or a custom handler that has the certain interface. The handler takes the same parameters as cvError function. If the handler returns non-zero value, the program is terminated, otherwise, it continues. The error handler may check the current error mode with cvGetErrMode to make a decision.
Public methodStatic memberReduce
Reduces matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained.
Public methodStatic memberRemap
Applies a generic geometrical transformation to an image.
Public methodStatic memberRepeat
Fills the destination array with source array tiled: dst(i,j)=src(i mod rows(src), j mod cols(src))So the destination array may be as larger as well as smaller than the source array
Public methodStatic memberReprojectImageTo3D
Transforms 1-channel disparity map to 3-channel image, a 3D surface.
Public methodStatic memberResize
Resizes the image src down to or up to the specified size
Public methodStatic memberRodrigues
Converts a rotation vector to rotation matrix or vice versa. Rotation vector is a compact representation of rotation matrix. Direction of the rotation vector is the rotation axis and the length of the vector is the rotation angle around the axis.
Public methodStatic memberRotatedRectangleIntersection
Finds out if there is any intersection between two rotated rectangles.
Public methodStatic memberSanityCheck
Check if the size of the C structures match those of C#
Public methodStatic memberSegmentMotion
Finds all the motion segments and marks them in segMask with individual values each (1,2,...). It also returns a sequence of CvConnectedComp structures, one per each motion components. After than the motion direction for every component can be calculated with cvCalcGlobalOrientation using extracted mask of the particular component (using cvCmp)
Public methodStatic memberSetErrMode
Sets the specified error mode.
Public methodStatic memberSetErrStatus
Sets the error status to the specified value. Mostly, the function is used to reset the error status (set to it CV_StsOk) to recover after error. In other cases it is more natural to call cvError or CV_ERROR.
Public methodStatic memberSetIdentity
Initializes scaled identity matrix: arr(i,j)=value if i=j, 0 otherwise
Public methodStatic memberSetNumThreads
Sets the number of threads that are used by parallelized OpenCV functions.
Public methodStatic memberSobel
The Sobel operators combine Gaussian smoothing and differentiation so the result is more or less robust to the noise. Most often, the function is called with (xorder=1, yorder=0, aperture_size=3) or (xorder=0, yorder=1, aperture_size=3) to calculate first x- or y- image derivative. The first case corresponds to
 
              |-1  0  1|
              |-2  0  2|
              |-1  0  1|
kernel and the second one corresponds to
              |-1 -2 -1|
              | 0  0  0|
              | 1  2  1|
or
              | 1  2  1|
              | 0  0  0|
              |-1 -2 -1|
kernel, depending on the image origin (origin field of IplImage structure). No scaling is done, so the destination image usually has larger by absolute value numbers than the source image. To avoid overflow, the function requires 16-bit destination image if the source image is 8-bit. The result can be converted back to 8-bit using cvConvertScale or cvConvertScaleAbs functions. Besides 8-bit images the function can process 32-bit floating-point images. Both source and destination must be single-channel images of equal size or ROI size
Public methodStatic memberSolve
Solves linear system (src1)*(dst) = (src2)
Public methodStatic memberSolveCubic
finds real roots of a cubic equation: coeffs[0]*x^3 + coeffs[1]*x^2 + coeffs[2]*x + coeffs[3] = 0 (if coeffs is 4-element vector) or x^3 + coeffs[0]*x^2 + coeffs[1]*x + coeffs[2] = 0 (if coeffs is 3-element vector)
Public methodStatic memberSolveLP
Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method). What we mean here by “linear programming problem” (or LP problem, for short) can be formulated as: Maximize c x subject to: Ax <= b and x >= 0
Public methodStatic memberSolvePnP(IInputArray, IInputArray, IInputArray, IInputArray, IOutputArray, IOutputArray, Boolean, SolvePnpMethod)
Estimates extrinsic camera parameters using known intrinsic parameters and extrinsic parameters for each view. The coordinates of 3D object points and their correspondent 2D projections must be specified. This function also minimizes back-projection error
Public methodStatic memberSolvePnP(MCvPoint3D32f, PointF, IInputArray, IInputArray, IOutputArray, IOutputArray, Boolean, SolvePnpMethod)
Estimates extrinsic camera parameters using known intrinsic parameters and extrinsic parameters for each view. The coordinates of 3D object points and their correspondent 2D projections must be specified. This function also minimizes back-projection error.
Public methodStatic memberSolvePnPRansac
Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
Public methodStatic memberSolvePoly
Finds all real and complex roots of any degree polynomial with real coefficients
Public methodStatic memberSplit
Divides a multi-channel array into separate single-channel arrays. Two modes are available for the operation. If the source array has N channels then if the first N destination channels are not IntPtr.Zero, all they are extracted from the source array, otherwise if only a single destination channel of the first N is not IntPtr.Zero, this particular channel is extracted, otherwise an error is raised. Rest of destination channels (beyond the first N) must always be IntPtr.Zero. For IplImage cvCopy with COI set can be also used to extract a single channel from the image
Public methodStatic memberSqrt
Calculate square root of each source array element. in the case of multichannel arrays each channel is processed independently. The function accuracy is approximately the same as of the built-in std::sqrt.
Public methodStatic memberStereoCalibrate(IInputArray, IInputArray, IInputArray, IInputOutputArray, IInputOutputArray, IInputOutputArray, IInputOutputArray, Size, IOutputArray, IOutputArray, IOutputArray, IOutputArray, CalibType, MCvTermCriteria)
Estimates transformation between the 2 cameras making a stereo pair. If we have a stereo camera, where the relative position and orientatation of the 2 cameras is fixed, and if we computed poses of an object relative to the fist camera and to the second camera, (R1, T1) and (R2, T2), respectively (that can be done with cvFindExtrinsicCameraParams2), obviously, those poses will relate to each other, i.e. given (R1, T1) it should be possible to compute (R2, T2) - we only need to know the position and orientation of the 2nd camera relative to the 1st camera. That's what the described function does. It computes (R, T) such that: R2=R*R1, T2=R*T1 + T
Public methodStatic memberStereoCalibrate(MCvPoint3D32f, PointF, PointF, IInputOutputArray, IInputOutputArray, IInputOutputArray, IInputOutputArray, Size, IOutputArray, IOutputArray, IOutputArray, IOutputArray, CalibType, MCvTermCriteria)
Estimates transformation between the 2 cameras making a stereo pair. If we have a stereo camera, where the relative position and orientatation of the 2 cameras is fixed, and if we computed poses of an object relative to the fist camera and to the second camera, (R1, T1) and (R2, T2), respectively (that can be done with cvFindExtrinsicCameraParams2), obviously, those poses will relate to each other, i.e. given (R1, T1) it should be possible to compute (R2, T2) - we only need to know the position and orientation of the 2nd camera relative to the 1st camera. That's what the described function does. It computes (R, T) such that: R2=R*R1, T2=R*T1 + T
Public methodStatic memberStereoRectify
computes the rotation matrices for each camera that (virtually) make both camera image planes the same plane. Consequently, that makes all the epipolar lines parallel and thus simplifies the dense stereo correspondence problem. On input the function takes the matrices computed by cvStereoCalibrate and on output it gives 2 rotation matrices and also 2 projection matrices in the new coordinates. The function is normally called after cvStereoCalibrate that computes both camera matrices, the distortion coefficients, R and T
Public methodStatic memberStereoRectifyUncalibrated
computes the rectification transformations without knowing intrinsic parameters of the cameras and their relative position in space, hence the suffix "Uncalibrated". Another related difference from cvStereoRectify is that the function outputs not the rectification transformations in the object (3D) space, but the planar perspective transformations, encoded by the homography matrices H1 and H2. The function implements the following algorithm [Hartley99].
Public methodStatic memberStylization
Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.
Public methodStatic memberSubtract
Subtracts one array from another one: dst(I)=src1(I)-src2(I) if mask(I)!=0 All the arrays must have the same type, except the mask, and the same size (or ROI size)
Public methodStatic memberSum
Calculates sum S of array elements, independently for each channel Sc = sumI arr(I)c If the array is IplImage and COI is set, the function processes the selected channel only and stores the sum to the first scalar component (S0).
Public methodStatic memberSVBackSubst
Performs a singular value back substitution.
Public methodStatic memberSVDecomp
Decomposes matrix A into a product of a diagonal matrix and two orthogonal matrices: A=U*W*VT Where W is diagonal matrix of singular values that can be coded as a 1D vector of singular values and U and V. All the singular values are non-negative and sorted (together with U and V columns) in descenting order.
Public methodStatic memberTextureFlattening
By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.
Public methodStatic memberThreshold
Applies fixed-level thresholding to single-channel array. The function is typically used to get bi-level (binary) image out of grayscale image (cvCmpS could be also used for this purpose) or for removing a noise, i.e. filtering out pixels with too small or too large values. There are several types of thresholding the function supports that are determined by threshold_type
Public methodStatic memberTrace
Returns sum of diagonal elements of the matrix mat.
Public methodStatic memberTransform
Performs matrix transformation of every element of array src and stores the results in dst Both source and destination arrays should have the same depth and the same size or selected ROI size. transmat and shiftvec should be real floating-point matrices.
Public methodStatic memberTranspose
Transposes matrix src1: dst(i,j)=src(j,i) Note that no complex conjugation is done in case of complex matrix. Conjugation should be done separately: look at the sample code in cvXorS for example
Public methodStatic memberTriangulatePoints
Reconstructs points by triangulation.
Public methodStatic memberUndistort
Transforms the image to compensate radial and tangential lens distortion.
Public methodStatic memberUndistortPoints
Similar to cvInitUndistortRectifyMap and is opposite to it at the same time. The functions are similar in that they both are used to correct lens distortion and to perform the optional perspective (rectification) transformation. They are opposite because the function cvInitUndistortRectifyMap does actually perform the reverse transformation in order to initialize the maps properly, while this function does the forward transformation.
Public methodStatic memberUpdateMotionHistory
Updates the motion history image as following: mhi(x,y)=timestamp if silhouette(x,y)!=0 0 if silhouette(x,y)=0 and mhi(x,y)<timestamp-duration mhi(x,y) otherwise That is, MHI pixels where motion occurs are set to the current timestamp, while the pixels where motion happened far ago are cleared.
Public methodStatic memberVConcat
Vertically concatenate two images
Public methodStatic memberWaitKey
Waits for key event infinitely (delay <= 0) or for "delay" milliseconds.
Public methodStatic memberWarpAffine
Applies an affine transformation to an image.
Public methodStatic memberWarpPerspective
Applies a perspective transformation to an image
Public methodStatic memberWatershed
Implements one of the variants of watershed, non-parametric marker-based segmentation algorithm, described in [Meyer92] Before passing the image to the function, user has to outline roughly the desired regions in the image markers with positive (>0) indices, i.e. every region is represented as one or more connected components with the pixel values 1, 2, 3 etc. Those components will be "seeds" of the future image regions. All the other pixels in markers, which relation to the outlined regions is not known and should be defined by the algorithm, should be set to 0's. On the output of the function, each pixel in markers is set to one of values of the "seed" components, or to -1 at boundaries between the regions.
Top
Fields
  NameDescription
Public fieldStatic memberBoolMarshalType
Represent a bool value in C++
Public fieldStatic memberBoolToIntMarshalType
Represent a int value in C++
Public fieldStatic memberCvCallingConvention
Opencv's calling convention
Public fieldStatic memberCvErrorHandlerIgnoreError
An error handler which will ignore any error and continue
Public fieldStatic memberCvErrorHandlerThrowException
The default Exception callback to handle Error thrown by OpenCV
Public fieldStatic memberExternCudaLibrary
The file name of the cvextern library
Public fieldStatic memberExternLibrary
The file name of the cvextern library
Public fieldStatic memberMorphologyDefaultBorderValue
The default morphology value.
Public fieldStatic memberOpencvFFMpegLibrary
The file name of the opencv_ffmpeg library
Public fieldStatic memberOpenCVModuleList
The List of the opencv modules
Public fieldStatic memberStringMarshalType
string marshaling type
Top
Properties
  NameDescription
Public propertyStatic memberHaveOpenCL
Check if we have OpenCL
Public propertyStatic memberHaveOpenCLCompatibleGpuDevice
Gets a value indicating whether this device have open CL compatible gpu device.
Public propertyStatic memberUseOpenCL
Get or set if OpenCL should be used
Public propertyStatic memberUseOptimized
Enables or disables the optimized code.
Top
See Also