Managed wrapper of all OpenCV functions
Inheritance Hierarchy
OpenCvSharpCv
Namespace: OpenCvSharp
Assembly: OpenCvSharp (in OpenCvSharp.dll) Version: 1.0.0.0 (1.0.0.0)
Syntax
The Cv type exposes the following members.
Methods
Name | Description | |
---|---|---|
_2DRotationMatrix(CvPoint2D32f, Double, Double) |
Calculates affine matrix of 2d rotation.
| |
_2DRotationMatrix(CvPoint2D32f, Double, Double, CvMat) |
Calculates affine matrix of 2d rotation.
| |
Abs |
Calculates absolute difference between array and scalar
| |
AbsDiff |
Calculates absolute difference between two arrays
| |
AbsDiffS |
Calculates absolute difference between array and scalar
| |
Acc(CvArr, CvArr) |
Adds frame to accumulator
| |
Acc(CvArr, CvArr, CvArr) |
Adds frame to accumulator
| |
AdaptiveThreshold(CvArr, CvArr, Double) |
Applies adaptive threshold to array.
| |
AdaptiveThreshold(CvArr, CvArr, Double, AdaptiveThresholdType) |
Applies adaptive threshold to array.
| |
AdaptiveThreshold(CvArr, CvArr, Double, AdaptiveThresholdType, ThresholdType) |
Applies adaptive threshold to array.
| |
AdaptiveThreshold(CvArr, CvArr, Double, AdaptiveThresholdType, ThresholdType, Int32) |
Applies adaptive threshold to array.
| |
AdaptiveThreshold(CvArr, CvArr, Double, AdaptiveThresholdType, ThresholdType, Int32, Double) |
Applies adaptive threshold to array.
| |
Add(CvArr, CvArr, CvArr) |
Computes per-element sum of two arrays
| |
Add(CvArr, CvArr, CvArr, CvArr) |
Computes per-element sum of two arrays
| |
AddS(CvArr, CvScalar, CvArr) |
Computes sum of array and scalar
| |
AddS(CvArr, CvScalar, CvArr, CvArr) |
Computes sum of array and scalar
| |
AddText |
Create the font to be used to draw text on an image
| |
AddWeighted |
Computes weighted sum of two arrays
| |
Alloc |
Allocates memory buffer
| |
And(CvArr, CvArr, CvArr) |
Calculates per-element bit-wise conjunction of two arrays
| |
And(CvArr, CvArr, CvArr, CvArr) |
Calculates per-element bit-wise conjunction of two arrays
| |
AndS(CvArr, CvScalar, CvArr) |
Calculates per-element bit-wise conjunction of array and scalar
| |
AndS(CvArr, CvScalar, CvArr, CvArr) |
Calculates per-element bit-wise conjunction of array and scalar
| |
ApproxChains(CvChain, CvMemStorage) |
Approximates Freeman chain(s) with polygonal curve
| |
ApproxChains(CvChain, CvMemStorage, ContourChain) |
Approximates Freeman chain(s) with polygonal curve
| |
ApproxChains(CvChain, CvMemStorage, ContourChain, Double) |
Approximates Freeman chain(s) with polygonal curve
| |
ApproxChains(CvChain, CvMemStorage, ContourChain, Double, Int32) |
Approximates Freeman chain(s) with polygonal curve
| |
ApproxChains(CvChain, CvMemStorage, ContourChain, Double, Int32, Boolean) |
Approximates Freeman chain(s) with polygonal curve
| |
ApproxPoly(CvSeqCvPoint, Int32, CvMemStorage, ApproxPolyMethod, Double) |
Approximates polygonal curve(s) with desired precision.
| |
ApproxPoly(CvSeqCvPoint, Int32, CvMemStorage, ApproxPolyMethod, Double, Boolean) |
Approximates polygonal curve(s) with desired precision.
| |
ArcLength(CvArr) |
Calculates contour perimeter or curve length
| |
ArcLength(CvArr, CvSlice) |
Calculates contour perimeter or curve length
| |
ArcLength(CvArr, CvSlice, Int32) |
Calculates contour perimeter or curve length
| |
ARE_CNS_EQ | ||
ARE_DEPTHS_EQ | ||
ARE_SIZES_EQ | ||
ARE_TYPES_EQ(CvMat, CvMat) | ||
ARE_TYPES_EQ(CvMatND, CvMatND) | ||
ARE_TYPES_EQ(CvSparseMat, CvSparseMat) | ||
AttrList |
initializes CvAttrList structure
| |
AttrList(String) |
initializes CvAttrList structure
| |
AttrList(String, PointerCvAttrList) |
initializes CvAttrList structure
| |
Avg(CvArr) |
Calculates average (mean) of array elements
| |
Avg(CvArr, CvArr) |
Calculates average (mean) of array elements
| |
AvgSdv(CvArr, CvScalar, CvScalar) |
Calculates average (mean) of array elements
| |
AvgSdv(CvArr, CvScalar, CvScalar, CvArr) |
Calculates average (mean) of array elements
| |
AXPY |
cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
| |
BackProjectPCA |
Reconstructs the original vectors from the projection coefficients
| |
BGCodeBookClearStale(CvBGCodeBookModel, Int32) | ||
BGCodeBookClearStale(CvBGCodeBookModel, Int32, CvRect) | ||
BGCodeBookClearStale(CvBGCodeBookModel, Int32, CvRect, CvArr) | ||
BGCodeBookDiff(CvBGCodeBookModel, CvArr, CvArr) | ||
BGCodeBookDiff(CvBGCodeBookModel, CvArr, CvArr, CvRect) | ||
BGCodeBookUpdate(CvBGCodeBookModel, CvArr) | ||
BGCodeBookUpdate(CvBGCodeBookModel, CvArr, CvRect) | ||
BGCodeBookUpdate(CvBGCodeBookModel, CvArr, CvRect, CvArr) | ||
BoundingRect(CvArr) |
Calculates up-right bounding rectangle of point set.
| |
BoundingRect(IEnumerableCvPoint) |
Calculates up-right bounding rectangle of point set.
| |
BoundingRect(CvArr, Boolean) |
Calculates up-right bounding rectangle of point set.
| |
BoxPoints |
Finds box vertices
| |
CalcAffineFlowPyrLK |
Modification of a previous sparse optical flow algorithm to calculate affine flow
| |
CalcArrBackProject |
Calculates back projection
| |
CalcArrBackProjectPatch(CvArr, CvArr, CvSize, CvHistogram, HistogramComparison) |
Locates a template within image by histogram comparison
| |
CalcArrBackProjectPatch(CvArr, CvArr, CvSize, CvHistogram, HistogramComparison, Single) |
Locates a template within image by histogram comparison
| |
CalcArrHist(CvArr, CvHistogram) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcArrHist(CvArr, CvHistogram) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcArrHist(CvArr, CvHistogram, Boolean) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcArrHist(CvArr, CvHistogram, Boolean) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcArrHist(CvArr, CvHistogram, Boolean, CvArr) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcArrHist(CvArr, CvHistogram, Boolean, CvArr) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcBackProject |
Calculates back projection
| |
CalcBackProjectPatch(IplImage, CvArr, CvSize, CvHistogram, HistogramComparison) |
Locates a template within image by histogram comparison
| |
CalcBackProjectPatch(IplImage, CvArr, CvSize, CvHistogram, HistogramComparison, Single) |
Locates a template within image by histogram comparison
| |
CalcBayesianProb |
Calculates bayesian probabilistic histograms
| |
CalcCovarMatrix |
Calculates covariation matrix of the set of vectors
| |
CalcCovarMatrixEx(IplImage, IplImage, Single) |
Calculates the covariance matrix for a group of input objects. (ioFlags = CV_EIGOBJ_NO_CALLBACK)
| |
CalcCovarMatrixEx(Int32, CvCallback, EigenObjectsIOFlag, Int32, Byte, IntPtr, IplImage, Single) |
Calculates the covariance matrix for a group of input objects.
| |
CalcDecompCoeff |
Calculates the decomposition coefficient of an input object.
| |
CalcEigenObjects(IplImage, IplImage, Int32, CvTermCriteria, IplImage, Single) |
Calculates the orthonormal eigen basis and the averaged object for group a of input objects. (ioFlags = CV_EIGOBJ_NO_CALLBACK)
| |
CalcEigenObjects(Int32, CvCallback, IplImage, Int32, IntPtr, CvTermCriteria, IplImage, Single) |
Calculates the orthonormal eigen basis and the averaged object for group a of input objects. (ioFlags = CV_EIGOBJ_INPUT_CALLBACK)
| |
CalcEigenObjects(Int32, IplImage, CvCallback, Int32, IntPtr, CvTermCriteria, IplImage, Single) |
Calculates the orthonormal eigen basis and the averaged object for group a of input objects. (ioFlags = CV_EIGOBJ_OUTPUT_CALLBACK)
| |
CalcEigenObjects(Int32, CvCallback, CvCallback, EigenObjectsIOFlag, Int32, IntPtr, CvTermCriteria, IplImage, Single) |
Calculates the orthonormal eigen basis and the averaged object for group a of input objects.
| |
CalcEMD2(CvArr, CvArr, DistanceType) |
Computes "minimal work" distance between two weighted point configurations.
| |
CalcEMD2(CvArr, CvArr, DistanceType, CvDistanceFunction) |
Computes "minimal work" distance between two weighted point configurations.
| |
CalcEMD2(CvArr, CvArr, DistanceType, CvDistanceFunction, CvArr) |
Computes "minimal work" distance between two weighted point configurations.
| |
CalcEMD2(CvArr, CvArr, DistanceType, CvDistanceFunction, CvArr, CvArr) |
Computes "minimal work" distance between two weighted point configurations.
| |
CalcEMD2(CvArr, CvArr, DistanceType, CvDistanceFunction, CvArr, CvArr, Single) |
Computes "minimal work" distance between two weighted point configurations.
| |
CalcGlobalOrientation |
Calculates global motion orientation of some selected region
| |
CalcHist(IplImage, CvHistogram) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcHist(IplImage, CvHistogram) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcHist(IplImage, CvHistogram, Boolean) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcHist(IplImage, CvHistogram, Boolean) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcHist(IplImage, CvHistogram, Boolean, CvArr) |
Calculates the histogram of one single-channel image.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcHist(IplImage, CvHistogram, Boolean, CvArr) |
Calculates the histogram of single-channel images.
The elements of a tuple that is used to increment a histogram bin are taken at the same location from the corresponding input images.
| |
CalcImageHomography |
Calculates homography matrix for oblong planar object (e.g. arm)
| |
CalcMatMulDeriv |
Computes d(AB)/dA and d(AB)/dB
| |
CalcMotionGradient(CvArr, CvArr, CvArr, Double, Double) |
Calculates gradient orientation of motion history image
| |
CalcMotionGradient(CvArr, CvArr, CvArr, Double, Double, ApertureSize) |
Calculates gradient orientation of motion history image
| |
CalcOpticalFlowBM |
Calculates optical flow for two images by block matching method
| |
CalcOpticalFlowFarneback |
Estimate optical flow for each pixel using the two-frame G. Farneback algorithm
| |
CalcOpticalFlowHS |
Computes flow for every pixel of the first input image using Horn & Schunck algorithm
| |
CalcOpticalFlowLK |
Computes flow for every pixel of the first input image using Lucas & Kanade algorithm
| |
CalcOpticalFlowPyrLK(CvArr, CvArr, CvArr, CvArr, CvPoint2D32f, CvPoint2D32f, CvSize, Int32, SByte, CvTermCriteria, LKFlowFlag) |
Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in pyramids
| |
CalcOpticalFlowPyrLK(CvArr, CvArr, CvArr, CvArr, CvPoint2D32f, CvPoint2D32f, CvSize, Int32, SByte, Single, CvTermCriteria, LKFlowFlag) |
Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in pyramids
| |
CalcPCA |
Performs Principal Component Analysis of a vector set
| |
CalcPGH |
Calculates pair-wise geometrical histogram for contour
| |
CalcProbDensity(CvHistogram, CvHistogram, CvHistogram) |
Divides one histogram by another.
| |
CalcProbDensity(CvHistogram, CvHistogram, CvHistogram, Double) |
Divides one histogram by another.
| |
CalcSubdivVoronoi2D |
Calculates coordinates of Voronoi diagram cells.
| |
CalibrateCamera2(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrateCamera2(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrateCamera2(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CalibrationFlag) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrateCamera2(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CalibrationFlag, Double) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize, Double, Double) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize, Double, Double, Double, Double) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize, Double, Double, Double, Double, Double) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize, Double, Double, Double, Double, Double, CvPoint2D64f) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CalibrationMatrixValues(CvMat, CvSize, Double, Double, Double, Double, Double, CvPoint2D64f, Double) |
Finds intrinsic and extrinsic camera parameters using calibration pattern
| |
CamShift(CvArr, CvRect, CvTermCriteria) |
Finds object center, size, and orientation
| |
CamShift(CvArr, CvRect, CvTermCriteria, CvConnectedComp) |
Finds object center, size, and orientation
| |
CamShift(CvArr, CvRect, CvTermCriteria, CvConnectedComp, CvBox2D) |
Finds object center, size, and orientation
| |
Canny(CvArr, CvArr, Double, Double) |
Finds the edges on the input image 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.
| |
Canny(CvArr, CvArr, Double, Double, ApertureSize) |
Finds the edges on the input image 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.
| |
CartToPolar(CvArr, CvArr, CvArr) |
Calculates magnitude and/or angle of 2d vectors
| |
CartToPolar(CvArr, CvArr, CvArr, CvArr) |
Calculates magnitude and/or angle of 2d vectors
| |
CartToPolar(CvArr, CvArr, CvArr, CvArr, AngleUnit) |
Calculates magnitude and/or angle of 2d vectors
| |
Cbrt |
Calculates cubic root
| |
Ceil |
Returns the minimum integer value that is not smaller than the argument.
| |
CheckArr(CvArr) |
Checks every element of input array for invalid values
| |
CheckArr(CvArr, CheckArrFlag) |
Checks every element of input array for invalid values
| |
CheckArr(CvArr, CheckArrFlag, Double, Double) |
Checks every element of input array for invalid values
| |
CheckArray(CvArr) |
Checks every element of input array for invalid values
| |
CheckArray(CvArr, CheckArrFlag) |
Checks every element of input array for invalid values
| |
CheckArray(CvArr, CheckArrFlag, Double, Double) |
Checks every element of input array for invalid values
| |
CheckChessboard |
Performs a fast check if a chessboard is in the input image.
This is a workaround to a problem of cvFindChessboardCorners being slow on images with no chessboard
| |
CheckContourConvexity |
Tests contour convexity.
| |
CheckTermCriteria |
Check termination criteria and transform it so that type=CriteriaType.Iteration | CriteriaType.Epsilon,
and both max_iter and epsilon are valid
| |
Circle(CvArr, CvPoint, Int32, CvScalar) |
Draws a circle
| |
Circle(CvArr, CvPoint, Int32, CvScalar, Int32) |
Draws a circle
| |
Circle(CvArr, Int32, Int32, Int32, CvScalar) |
Draws a circle
| |
Circle(CvArr, CvPoint, Int32, CvScalar, Int32, LineType) |
Draws a circle
| |
Circle(CvArr, Int32, Int32, Int32, CvScalar, Int32) |
Draws a circle
| |
Circle(CvArr, CvPoint, Int32, CvScalar, Int32, LineType, Int32) |
Draws a circle
| |
Circle(CvArr, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws a circle
| |
Circle(CvArr, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws a circle
| |
ClearGraph |
Returns index of graph vertex
| |
ClearHist |
Sets all histogram bins to 0 in case of dense histogram and removes all histogram bins in case of sparse array.
| |
ClearMemStorage |
Clears memory storage
| |
ClearND |
Clears the particular array element
| |
ClearSeq |
Clears sequence
| |
ClearSet |
Clears set
| |
ClearSubdivVoronoi2D |
Removes all virtual points
| |
ClipLine |
Clips the line against the image rectangle
| |
Clone(IntPtr) |
Makes a clone of the object
| |
CloneT(T) |
Makes a clone of the object
| |
CloneGraph |
Clone graph
| |
CloneImage |
Makes a full copy of image
| |
CloneMat |
Creates matrix copy
| |
CloneMatND |
Creates full copy of multi-dimensional array
| |
CloneSeq(CvSeq) |
Creates a copy of sequence
| |
CloneSeq(CvSeq, CvMemStorage) |
Creates a copy of sequence
| |
CloneSeqT(CvSeqT) |
Creates a copy of sequence
| |
CloneSeqT(CvSeqT, CvMemStorage) |
Creates a copy of sequence
| |
CloneSparseMat |
Creates full copy of sparse array
| |
Cmp |
Performs per-element comparison of two arrays
| |
CmpS |
Performs per-element comparison of array and scalar
| |
CompareHist |
Compares two dense histograms.
| |
CompleteSymm(CvMat) |
Completes the symmetric matrix from the lower part
| |
CompleteSymm(CvMat, Boolean) |
Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part
| |
ComposeRT |
Computes r3 = rodrigues(rodrigues(r2)*rodrigues(r1)),
t3 = rodrigues(r2)*t1 + t2 and the respective derivatives
| |
ComputeCorrespondEpilines |
For points in one image of stereo pair computes the corresponding epilines in the other image
| |
ConDensInitSampleSet |
Initializes sample set for ConDensation algorithm
| |
ConDensUpdateByTime |
Estimates subsequent model state
| |
ContourArea(CvArr) |
Calculates area of the whole contour or contour section.
| |
ContourArea(CvArr, CvSlice) |
Calculates area of the whole contour or contour section.
| |
ContourFromContourTree |
Restores contour from tree.
| |
ContourPerimeter |
Alias for cvArcLength(curve,Whole_Seq,1)
| |
ContoursMoments |
Alias for Moments with CvSeq contours
| |
Convert |
Converts one array to another with optional linear transformation
| |
ConvertImage |
Converts one image to another and flips the result vertically if required.
| |
ConvertMaps |
Converts mapx & mapy from floating-point to integer formats for cvRemap
| |
ConvertPointsHomogeneous |
Convert points to/from homogeneous coordinates
| |
ConvertPointsHomogenious |
Convert points to/from homogeneous coordinates
| |
ConvertScale(CvArr, CvArr) |
Converts one array to another with optional linear transformation
| |
ConvertScale(CvArr, CvArr, Double) |
Converts one array to another with optional linear transformation
| |
ConvertScale(CvArr, CvArr, Double, Double) |
Converts one array to another with optional linear transformation
| |
ConvertScaleAbs(CvArr, CvArr) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
ConvertScaleAbs(CvArr, CvArr, Double) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
ConvertScaleAbs(CvArr, CvArr, Double, Double) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
ConvexHull2(CvArr, CvPoint, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvArr, CvPoint2D32f, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvArr, Int32, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvPoint, CvPoint, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvPoint, Int32, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvPoint2D32f, CvPoint2D32f, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexHull2(CvPoint2D32f, Int32, ConvexHullOrientation) |
Finds convex hull of point set
| |
ConvexityDefects(CvArr, CvArr) |
Finds convexity defects of contour
| |
ConvexityDefects(CvArr, Int32) |
Finds convexity defects of contour
| |
ConvexityDefects(CvArr, CvArr, CvMemStorage) |
Finds convexity defects of contour
| |
Copy(CvArr, CvArr) |
Copies one array to another
| |
Copy(CvArr, CvArr, CvArr) |
Copies one array to another
| |
CopyHist |
The function cvCopyHist makes a copy of the histogram.
If the second histogram pointer dst is null, a new histogram of the same size as src is created.
Otherwise, both histograms must have equal types and sizes.
Then the function copies the source histogram bins values to destination histogram and sets the same bin values ranges as in src.
| |
CopyMakeBorder(CvArr, CvArr, CvPoint, BorderType) |
Copies image and makes border around it.
| |
CopyMakeBorder(CvArr, CvArr, CvPoint, BorderType, CvScalar) |
Copies image and makes border around it.
| |
CornerEigenValsAndVecs(CvArr, CvArr, Int32) |
Calculates eigenvalues and eigenvectors of image blocks for corner detection
| |
CornerEigenValsAndVecs(CvArr, CvArr, Int32, ApertureSize) |
Calculates eigenvalues and eigenvectors of image blocks for corner detection
| |
CornerHarris(CvArr, CvArr, Int32) |
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×block_size neighborhood.
| |
CornerHarris(CvArr, CvArr, Int32, ApertureSize) |
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×block_size neighborhood.
| |
CornerHarris(CvArr, CvArr, Int32, ApertureSize, Double) |
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×block_size neighborhood.
| |
CornerMinEigenVal(CvArr, CvArr, Int32) |
Calculates minimal eigenvalue of gradient matrices for corner detection
| |
CornerMinEigenVal(CvArr, CvArr, Int32, ApertureSize) |
Calculates minimal eigenvalue of gradient matrices for corner detection
| |
CorrectMatches |
The Optimal Triangulation Method
| |
CountNonZero |
Counts non-zero array elements
| |
CreateBGCodeBookModel | ||
CreateButton |
Create a button on the control panel
| |
CreateButton(String) |
Create a button on the control panel
| |
CreateButton(String, CvButtonCallback) |
Create a button on the control panel
| |
CreateButton(String, CvButtonCallback, Object) |
Create a button on the control panel
| |
CreateButton(String, CvButtonCallback, Object, ButtonType) |
Create a button on the control panel
| |
CreateButton(String, CvButtonCallback, Object, ButtonType, Int32) |
Create a button on the control panel
| |
CreateCameraCapture(Int32) |
Allocates and initialized the CvCapture structure for reading a video stream from the camera.
Currently two camera interfaces can be used on Windows: Video for Windows (VFW) and Matrox Imaging Library (MIL); and two on Linux: V4L and FireWire (IEEE1394).
| |
CreateCameraCapture(CaptureDevice) |
Allocates and initialized the CvCapture structure for reading a video stream from the camera.
Currently two camera interfaces can be used on Windows: Video for Windows (VFW) and Matrox Imaging Library (MIL); and two on Linux: V4L and FireWire (IEEE1394).
| |
CreateChildMemStorage |
Creates child memory storage
| |
CreateConDensation |
Allocates ConDensation filter structure
| |
CreateContourTree |
Creates hierarchical representation of contour
| |
CreateData |
Allocates array data.
| |
CreateFeatureTree |
Constructs a tree of feature vectors
| |
CreateFileCapture |
Allocates and initialized the CvCapture structure for reading the video stream from the specified file.
After the allocated structure is not used any more it should be released by cvReleaseCapture function.
| |
CreateGraph(SeqType, Int32, Int32, CvMemStorage) |
Creates empty graph
| |
CreateGraph(SeqType, Int32, Int32, CvMemStorage, Int32) |
Creates empty graph
| |
CreateGraphScanner(CvGraph) |
Creates structure for depth-first graph traversal
| |
CreateGraphScanner(CvGraph, CvGraphVtx) |
Creates structure for depth-first graph traversal
| |
CreateGraphScanner(CvGraph, CvGraphVtx, GraphScannerMask) |
Creates structure for depth-first graph traversal
| |
CreateHist(Int32, HistogramFormat) |
Creates a histogram of the specified size and returns the pointer to the created histogram.
| |
CreateHist(Int32, HistogramFormat, Single) |
Creates a histogram of the specified size and returns the pointer to the created histogram.
| |
CreateHist(Int32, HistogramFormat, Single, Boolean) |
Creates a histogram of the specified size and returns the pointer to the created histogram.
| |
CreateImage |
Creates header and allocates data
| |
CreateImageHeader |
Allocates, initializes, and returns structure IplImage
| |
CreateKalman(Int32, Int32) |
Allocates Kalman filter structure
| |
CreateKalman(Int32, Int32, Int32) |
Allocates Kalman filter structure
| |
CreateKDTree |
Constructs kd-tree from set of feature descriptors
| |
CreateLSH(IntPtr, Int32) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateLSH(IntPtr, Int32, Int32) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateLSH(IntPtr, Int32, Int32, Int32) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateLSH(IntPtr, Int32, Int32, Int32, MatrixType) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateLSH(IntPtr, Int32, Int32, Int32, MatrixType, Double) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateLSH(IntPtr, Int32, Int32, Int32, MatrixType, Double, Int64) |
Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
| |
CreateMat |
Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix.
| |
CreateMatHeader |
allocates new matrix header and returns pointer to it.
The matrix data can further be allocated using cvCreateData or set explicitly to user-allocated data via cvSetData.
| |
CreateMatND |
Allocates header for multi-dimensional dense array and the underlying data, and returns pointer to the created array.
| |
CreateMatNDHeader |
Allocates header for multi-dimensional dense array.
The array data can further be allocated using cvCreateData or set explicitly to user-allocated data via cvSetData.
| |
CreateMemoryLSH(Int32, Int32) |
Construct in-memory LSH table, with n bins.
| |
CreateMemoryLSH(Int32, Int32, Int32) |
Construct in-memory LSH table, with n bins.
| |
CreateMemoryLSH(Int32, Int32, Int32, Int32) |
Construct in-memory LSH table, with n bins.
| |
CreateMemoryLSH(Int32, Int32, Int32, Int32, MatrixType) |
Construct in-memory LSH table, with n bins.
| |
CreateMemoryLSH(Int32, Int32, Int32, Int32, MatrixType, Double) |
Construct in-memory LSH table, with n bins.
| |
CreateMemoryLSH(Int32, Int32, Int32, Int32, MatrixType, Double, Int64) |
Construct in-memory LSH table, with n bins.
| |
CreateMemStorage |
Creates memory storage
| |
CreateMemStorage(Int32) |
Creates memory storage
| |
CreatePOSITObject(CvPoint3D32f) |
Initializes structure containing object information
| |
CreatePOSITObject(CvPoint3D32f, Int32) |
Initializes structure containing object information
| |
CreatePyramid |
Builds pyramid for an image
| |
CreateSeq(SeqType, Int32, Int32, CvMemStorage) |
Creates sequence
| |
CreateSeqT(SeqType, Int32, CvMemStorage) |
Creates sequence
| |
CreateSeqBlock | ||
CreateSet |
Creates empty set
| |
CreateSparseMat |
Creates sparse array
| |
CreateSpillTree(CvMat) |
Constructs spill-tree from set of feature descriptors
| |
CreateSpillTree(CvMat, Int32) |
Constructs spill-tree from set of feature descriptors
| |
CreateSpillTree(CvMat, Int32, Double) |
Constructs spill-tree from set of feature descriptors
| |
CreateSpillTree(CvMat, Int32, Double, Double) |
Constructs spill-tree from set of feature descriptors
| |
CreateStereoBMState |
Creates block matching stereo correspondence structure
| |
CreateStereoBMState(StereoBMPreset) |
Creates block matching stereo correspondence structure
| |
CreateStereoBMState(StereoBMPreset, Int32) |
Creates block matching stereo correspondence structure
| |
CreateStereoGCState |
Creates the state of graph cut-based stereo correspondence algorithm
| |
CreateStructuringElementEx(Int32, Int32, Int32, Int32, ElementShape) |
Allocates and fills the structure IplConvKernel, which can be used as a structuring element in the morphological operations.
| |
CreateStructuringElementEx(Int32, Int32, Int32, Int32, ElementShape, Int32) |
Allocates and fills the structure IplConvKernel, which can be used as a structuring element in the morphological operations.
| |
CreateSubdiv2D |
Creates empty Delaunay triangulation.
The users must initialize the returned value by cvInitSubdivDelaunay2D.
| |
CreateSubdivDelaunay2D |
Creates empty Delaunay triangulation
| |
CreateTrackbar(String, String, Int32, Int32, CvTrackbarCallback) |
Creates the trackbar (a.k.a. slider or range control) with the specified name and range,
assigns the variable to be syncronized with trackbar position and specifies callback function to be called on trackbar position change.
The created trackbar is displayed on top of given window.
| |
CreateTrackbar(String, String, Int32, Int32, CvTrackbarCallback) |
Creates the trackbar (a.k.a. slider or range control) with the specified name and range,
assigns the variable to be syncronized with trackbar position and specifies callback function to be called on trackbar position change.
The created trackbar is displayed on top of given window.
| |
CreateTrackbar2 |
Creates the trackbar (a.k.a. slider or range control) with the specified name and range,
assigns the variable to be syncronized with trackbar position and specifies callback function to be called on trackbar position change.
The created trackbar is displayed on top of given window.
| |
CreateVideoWriter(String, String, Double, CvSize) |
Creates video writer structure.
| |
CreateVideoWriter(String, String, Double, CvSize, Boolean) |
Creates video writer structure.
| |
CrossProduct |
Calculates cross product of two 3D vectors
| |
CV_MAT_ELEMT | ||
CvtColor |
Converts image from one color space to another.
| |
CvtPixToPlane |
Divides multi-channel array into several single-channel arrays or extracts a single channel from the array
| |
CvtPlaneToPix |
Composes multi-channel array from several single-channel arrays or inserts a single channel into the array
| |
CvtScale(CvArr, CvArr) |
Converts one array to another with optional linear transformation
| |
CvtScale(CvArr, CvArr, Double) |
Converts one array to another with optional linear transformation
| |
CvtScale(CvArr, CvArr, Double, Double) |
Converts one array to another with optional linear transformation
| |
CvtScaleAbs(CvArr, CvArr) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
CvtScaleAbs(CvArr, CvArr, Double) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
CvtScaleAbs(CvArr, CvArr, Double, Double) |
Converts input array elements to 8-bit unsigned integer another with optional linear transformation
| |
CvtSeqToArrayT(CvSeq, T) |
Copies sequence to one continuous block of memory
| |
CvtSeqToArrayT(CvSeq, T, CvSlice) |
Copies sequence to one continuous block of memory
| |
DCT |
Performs forward or inverse Discrete Cosine transform of 1D or 2D floating-point array
| |
DecodeImage |
Decode image stored in the buffer
| |
DecodeImageM |
Decode image stored in the buffer
| |
DecomposeProjectionMatrix(CvMat, CvMat, CvMat, CvMat) |
Computes projection matrix decomposition
| |
DecomposeProjectionMatrix(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
Computes projection matrix decomposition
| |
DecomposeProjectionMatrix(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvPoint3D64f) |
Computes projection matrix decomposition
| |
DecRefData |
Decrements array data reference counter.
| |
DeleteMoire |
Deletes moire in given image
| |
DestroyAllWindows |
Destroys all the opened HighGUI windows.
| |
DestroyWindow |
Destroys the window with a given name.
| |
Det |
Returns determinant of matrix
| |
DFT(CvArr, CvArr, DFTFlag) |
Performs forward or inverse Discrete Fourier transform of 1D or 2D floating-point array
| |
DFT(CvArr, CvArr, DFTFlag, Int32) |
Performs forward or inverse Discrete Fourier transform of 1D or 2D floating-point array
| |
Dilate(CvArr, CvArr) |
Dilates image by using arbitrary structuring element.
| |
Dilate(CvArr, CvArr, IplConvKernel) |
Dilates image by using arbitrary structuring element.
| |
Dilate(CvArr, CvArr, IplConvKernel, Int32) |
Dilates image by using arbitrary structuring element.
| |
DisplayOverlay |
Display text on the window's image as an overlay for delay milliseconds. This is not editing the image's data. The text is display on the top of the image.
| |
DisplayStatusBar | ||
DistTransform(CvArr, CvArr) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
DistTransform(CvArr, CvArr, DistanceType) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
DistTransform(CvArr, CvArr, DistanceType, Int32) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
DistTransform(CvArr, CvArr, DistanceType, Int32, Single) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
DistTransform(CvArr, CvArr, DistanceType, Int32, Single, CvArr) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
DistTransform(CvArr, CvArr, DistanceType, Int32, Single, CvArr, DistTransformLabelType) |
Calculates distance to closest zero pixel for all non-zero pixels of source image.
| |
Div(CvArr, CvArr, CvArr) |
Performs per-element division of two arrays
| |
Div(CvArr, CvArr, CvArr, Double) |
Performs per-element division of two arrays
| |
DotProduct |
Calculates dot product of two arrays in Euclidean metrics
| |
DrawChessboardCorners |
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).
| |
DrawCircle(CvArr, CvPoint, Int32, CvScalar) |
Draws a circle
| |
DrawCircle(CvArr, CvPoint, Int32, CvScalar, Int32) |
Draws a circle
| |
DrawCircle(CvArr, Int32, Int32, Int32, CvScalar) |
Draws a circle
| |
DrawCircle(CvArr, CvPoint, Int32, CvScalar, Int32, LineType) |
Draws a circle
| |
DrawCircle(CvArr, Int32, Int32, Int32, CvScalar, Int32) |
Draws a circle
| |
DrawCircle(CvArr, CvPoint, Int32, CvScalar, Int32, LineType, Int32) |
Draws a circle
| |
DrawCircle(CvArr, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws a circle
| |
DrawCircle(CvArr, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws a circle
| |
DrawContours(CvArr, CvSeqCvPoint, CvScalar, CvScalar, Int32) |
Draws contour outlines or interiors in the image
| |
DrawContours(CvArr, CvSeqCvPoint, CvScalar, CvScalar, Int32, Int32) |
Draws contour outlines or interiors in the image
| |
DrawContours(CvArr, CvSeqCvPoint, CvScalar, CvScalar, Int32, Int32, LineType) |
Draws contour outlines or interiors in the image
| |
DrawContours(CvArr, CvSeqCvPoint, CvScalar, CvScalar, Int32, Int32, LineType, CvPoint) |
Draws contour outlines or interiors in the image
| |
DrawEllipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
DrawEllipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
DrawEllipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32, LineType) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
DrawEllipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32, LineType, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
DrawLine(CvArr, CvPoint, CvPoint, CvScalar) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, CvPoint, CvPoint, CvScalar, Int32) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, Int32, Int32, Int32, Int32, CvScalar) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws a line segment connecting two points
| |
DrawLine(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
DrawPolyLine(CvArr, CvPoint, Boolean, CvScalar) |
Draws simple or thick polygons
| |
DrawPolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32) |
Draws simple or thick polygons
| |
DrawPolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32, LineType) |
Draws simple or thick polygons
| |
DrawPolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32, LineType, Int32) |
Draws simple or thick polygons
| |
DrawRect(CvArr, CvRect, CvScalar) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvPoint, CvPoint, CvScalar) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvRect, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvPoint, CvPoint, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvRect, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvRect, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, Int32, Int32, Int32, Int32, CvScalar) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
DrawRect(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
EigenDecomposite(IplImage, IplImage, IplImage, Single) |
Calculates all of the decomposition coefficients for an input object. (ioFlags = CV_EIGOBJ_NO_CALLBACK)
| |
EigenDecomposite(IplImage, Int32, CvCallback, EigenObjectsIOFlag, IntPtr, IplImage, Single) |
Calculates all of the decomposition coefficients for an input object.
| |
EigenProjection(IplImage, Int32, Single, IplImage, IplImage) |
Calculates the object projection into the eigen sub-space. (ioFlags = CV_EIGOBJ_NO_CALLBACK)
| |
EigenProjection(CvCallback, Int32, EigenObjectsIOFlag, IntPtr, Single, IplImage, IplImage) |
Calculates the object projection into the eigen sub-space.
| |
EigenVV(CvArr, CvArr, CvArr) |
Computes eigenvalues and eigenvectors of symmetric matrix
| |
EigenVV(CvArr, CvArr, CvArr, Double) |
Computes eigenvalues and eigenvectors of symmetric matrix
| |
EigenVV(CvArr, CvArr, CvArr, Double, Int32) |
Computes eigenvalues and eigenvectors of symmetric matrix
| |
EigenVV(CvArr, CvArr, CvArr, Double, Int32, Int32) |
Computes eigenvalues and eigenvectors of symmetric matrix
| |
ELEM_SIZE | ||
ELEM_SIZE1 | ||
Ellipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
Ellipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
Ellipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32, LineType) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
Ellipse(CvArr, CvPoint, CvSize, Double, Double, Double, CvScalar, Int32, LineType, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
Ellipse2Poly |
Approximates elliptic arc with polyline
| |
EllipseBox(CvArr, CvBox2D, CvScalar) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
EllipseBox(CvArr, CvBox2D, CvScalar, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
EllipseBox(CvArr, CvBox2D, CvScalar, Int32, LineType) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
EllipseBox(CvArr, CvBox2D, CvScalar, Int32, LineType, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
EncodeImage(String, CvArr, ImageEncodingParam) |
Encode image and store the result as a byte vector (single-row 8uC1 matrix)
| |
EncodeImage(String, CvArr, Int32) |
Encode image and store the result as a byte vector (single-row 8uC1 matrix)
| |
EndFindContours |
Finishes scanning process
| |
EndWriteSeq |
Finishes process of writing sequence
| |
EndWriteStruct |
Ends writing a structure
| |
EqualizeHist |
Equalizes histogram of grayscale image.
| |
Erode(CvArr, CvArr) |
Erodes image by using arbitrary structuring element.
| |
Erode(CvArr, CvArr, IplConvKernel) |
Erodes image by using arbitrary structuring element.
| |
Erode(CvArr, CvArr, IplConvKernel, Int32) |
Erodes image by using arbitrary structuring element.
| |
Error |
Raises an error
| |
ErrorStr |
Returns textual description of error status code
| |
EstimateRigidTransform |
Estimate rigid transformation between 2 images or 2 point sets
| |
Exp |
Calculates exponent of every array element
| |
ExtractMSER |
Extracts the contours of Maximally Stable Extremal Regions
| |
ExtractSURF(CvArr, CvArr, CvSURFPoint, Single, CvSURFParams) |
Extracts Speeded Up Robust Features from image
| |
ExtractSURF(CvArr, CvArr, CvSeqCvSURFPoint, CvSeqIntPtr, CvMemStorage, CvSURFParams) |
Extracts Speeded Up Robust Features from image
| |
ExtractSURF(CvArr, CvArr, CvSURFPoint, Single, CvSURFParams, Boolean) |
Extracts Speeded Up Robust Features from image
| |
ExtractSURF(CvArr, CvArr, CvSeqCvSURFPoint, CvSeqIntPtr, CvMemStorage, CvSURFParams, Boolean) |
Extracts Speeded Up Robust Features from image
| |
FastArctan |
Calculates angle of 2D vector
| |
FFT(CvArr, CvArr, DFTFlag) |
Performs forward or inverse Discrete Fourier transform of 1D or 2D floating-point array
| |
FFT(CvArr, CvArr, DFTFlag, Int32) |
Performs forward or inverse Discrete Fourier transform of 1D or 2D floating-point array
| |
FillConvexPoly(CvArr, CvPoint, CvScalar) |
Fills convex polygon
| |
FillConvexPoly(CvArr, CvPoint, CvScalar, LineType) |
Fills convex polygon
| |
FillConvexPoly(CvArr, CvPoint, CvScalar, LineType, Int32) |
Fills convex polygon
| |
FillPoly(CvArr, CvPoint, CvScalar) |
Fills polygons interior
| |
FillPoly(CvArr, CvPoint, CvScalar, LineType) |
Fills polygons interior
| |
FillPoly(CvArr, CvPoint, CvScalar, LineType, Int32) |
Fills polygons interior
| |
Filter2D(CvArr, CvArr, CvMat) |
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.
| |
Filter2D(CvArr, CvArr, CvMat, CvPoint) |
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.
| |
FindChessboardCorners(CvArr, CvSize, CvPoint2D32f) |
Finds positions of internal corners of the chessboard
| |
FindChessboardCorners(CvArr, CvSize, CvPoint2D32f, Int32) |
Finds positions of internal corners of the chessboard
| |
FindChessboardCorners(CvArr, CvSize, CvPoint2D32f, Int32, ChessboardFlag) |
Finds positions of internal corners of the chessboard
| |
FindContours(CvArr, CvMemStorage, CvSeqCvPoint) |
Retrieves contours from the binary image and returns the number of retrieved contours.
| |
FindContours(CvArr, CvMemStorage, CvSeqCvPoint, Int32) |
Retrieves contours from the binary image and returns the number of retrieved contours.
| |
FindContours(CvArr, CvMemStorage, CvSeqCvPoint, Int32, ContourRetrieval) |
Retrieves contours from the binary image and returns the number of retrieved contours.
| |
FindContours(CvArr, CvMemStorage, CvSeqCvPoint, Int32, ContourRetrieval, ContourChain) |
Retrieves contours from the binary image and returns the number of retrieved contours.
| |
FindContours(CvArr, CvMemStorage, CvSeqCvPoint, Int32, ContourRetrieval, ContourChain, CvPoint) |
Retrieves contours from the binary image and returns the number of retrieved contours.
| |
FindCornerSubPix |
Iterates to find the sub-pixel accurate location of corners, or radial saddle points.
| |
FindDominantPoints |
Finds high-curvature points of the contour
| |
FindExtrinsicCameraParams2(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
Finds extrinsic camera parameters for particular view
| |
FindExtrinsicCameraParams2(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, Boolean) |
Finds extrinsic camera parameters for particular view
| |
FindFace | ||
FindFeatures(CvFeatureTree, CvMat, CvMat, CvMat) |
Finds approximate k nearest neighbors of given vectors using best-bin-first search.
| |
FindFeatures(CvFeatureTree, CvMat, CvMat, CvMat, Int32) |
Finds approximate k nearest neighbors of given vectors using best-bin-first search.
| |
FindFeatures(CvFeatureTree, CvMat, CvMat, CvMat, Int32, Int32) |
Finds approximate k nearest neighbors of given vectors using best-bin-first search.
| |
FindFeaturesBoxed |
Performs orthogonal range seaching on the given kd-tree.
| |
FindFundamentalMat(CvMat, CvMat, CvMat) |
Calculates fundamental matrix from corresponding points in two images
| |
FindFundamentalMat(CvMat, CvMat, CvMat, FundamentalMatMethod) |
Calculates fundamental matrix from corresponding points in two images
| |
FindFundamentalMat(CvMat, CvMat, CvMat, FundamentalMatMethod, Double, Double) |
Calculates fundamental matrix from corresponding points in two images
| |
FindFundamentalMat(CvMat, CvMat, CvMat, FundamentalMatMethod, Double, Double, CvMat) |
Calculates fundamental matrix from corresponding points in two images
| |
FindGraphEdge |
Finds edge in graph
| |
FindGraphEdgeByPtr |
Finds edge in graph
| |
FindHomography(CvMat, CvMat, CvMat) |
Finds perspective transformation between two planes
| |
FindHomography(CvMat, CvMat, CvMat, HomographyMethod) |
Finds perspective transformation between two planes
| |
FindHomography(CvMat, CvMat, CvMat, HomographyMethod, Double) |
Finds perspective transformation between two planes
| |
FindHomography(CvMat, CvMat, CvMat, HomographyMethod, Double, CvMat) |
Finds perspective transformation between two planes
| |
FindNearestPoint2D |
Finds the closest subdivision vertex to given point
| |
FindNextContour |
Finds next contour in the image
| |
FindStereoCorrespondence(CvArr, CvArr, DisparityMode, CvArr, Int32) |
Calculates disparity for stereo-pair
| |
FindStereoCorrespondence(CvArr, CvArr, DisparityMode, CvArr, Int32, Double, Double, Double, Double, Double) |
Calculates disparity for stereo-pair
| |
FindStereoCorrespondenceBM |
Computes the disparity map using block matching algorithm
| |
FindStereoCorrespondenceGC(CvArr, CvArr, CvArr, CvArr, CvStereoGCState) |
Computes the disparity map using graph cut-based algorithm
| |
FindStereoCorrespondenceGC(CvArr, CvArr, CvArr, CvArr, CvStereoGCState, Boolean) |
Computes the disparity map using graph cut-based algorithm
| |
FindType |
Finds type by its name
| |
FirstType |
Returns the beginning of type list
| |
FitEllipse2(CvArr) |
Fits ellipse to set of 2D points
| |
FitEllipse2(IEnumerableCvPoint2D32f) |
Fits ellipse to set of 2D points
| |
FitLine |
Fits line to 2D or 3D point set
| |
FitLine2D(IEnumerableCvPoint, DistanceType, Double, Double, Double) |
Fits line to 2D point set
| |
FitLine2D(IEnumerableCvPoint2D32f, DistanceType, Double, Double, Double) |
Fits line to 2D point set
| |
FitLine3D |
Fits line to 3D point set
| |
Flip(CvArr) |
Flip a 2D array around vertical, horizontal or both axises
| |
Flip(CvArr, CvArr) |
Flip a 2D array around vertical, horizontal or both axises
| |
Flip(CvArr, CvArr, FlipMode) |
Flip a 2D array around vertical, horizontal or both axises
| |
FloodFill(CvArr, CvPoint, CvScalar) |
Fills a connected component with given color.
| |
FloodFill(CvArr, CvPoint, CvScalar, CvScalar) |
Fills a connected component with given color.
| |
FloodFill(CvArr, CvPoint, CvScalar, CvScalar, CvScalar) |
Fills a connected component with given color.
| |
FloodFill(CvArr, CvPoint, CvScalar, CvScalar, CvScalar, CvConnectedComp) |
Fills a connected component with given color.
| |
FloodFill(CvArr, CvPoint, CvScalar, CvScalar, CvScalar, CvConnectedComp, FloodFillFlag) |
Fills a connected component with given color.
| |
FloodFill(CvArr, CvPoint, CvScalar, CvScalar, CvScalar, CvConnectedComp, FloodFillFlag, CvArr) |
Fills a connected component with given color.
| |
Floor |
Returns the maximum integer value that is not larger than the argument.
| |
FlushSeqWriter |
Updates sequence headers from the writer state
| |
FontQt(String) |
Create the font to be used to draw text on an image
| |
FontQt(String, Int32) |
Create the font to be used to draw text on an image
| |
FontQt(String, Int32, CvScalar) |
Create the font to be used to draw text on an image
| |
FontQt(String, Int32, CvScalar, FontWeight) |
Create the font to be used to draw text on an image
| |
FontQt(String, Int32, CvScalar, FontWeight, FontStyle) |
Create the font to be used to draw text on an image
| |
FontQt(String, Int32, CvScalar, FontWeight, FontStyle, Int32) |
Create the font to be used to draw text on an image
| |
FOURCC(String) |
4つの文字からFOURCCの整数値を得る
| |
FOURCC(Byte, Byte, Byte, Byte) |
4つの文字からFOURCCの整数値を得る
| |
FOURCC(Char, Char, Char, Char) |
4つの文字からFOURCCの整数値を得る
| |
Free |
Deallocates memory buffer
| |
GEMM(CvArr, CvArr, Double, CvArr, Double, CvArr) |
Performs generalized matrix multiplication
| |
GEMM(CvArr, CvArr, Double, CvArr, Double, CvArr, GemmOperation) |
Performs generalized matrix multiplication
| |
Get1D |
Return the particular array element
| |
Get2D |
Return the particular array element
| |
Get3D |
Return the particular array element
| |
GetAffineTransform(CvPoint2D32f, CvPoint2D32f) |
Calculates affine transform from 3 corresponding points.
| |
GetAffineTransform(CvPoint2D32f, CvPoint2D32f, CvMat) |
Calculates affine transform from 3 corresponding points.
| |
GetCaptureProperty(CvCapture, CaptureProperty) |
Retrieves the specified property of camera or video file.
| |
GetCaptureProperty(CvCapture, Int32) |
Retrieves the specified property of camera or video file.
| |
GetCentralMoment |
Retrieves central moment from moment state structure
| |
GetCol |
Returns array column
| |
GetCols |
Returns array column span
| |
GetDiag(CvArr, CvMat) |
Returns one of array diagonals
| |
GetDiag(CvArr, CvMat, DiagType) |
Returns one of array diagonals
| |
GetDims(CvArr) |
Return number of array dimensions and their sizes
| |
GetDims(CvArr, Int32) |
Return number of array dimensions and their sizes
| |
GetDimSize |
Return the size of particular dimension
| |
GetElemType |
Returns type of array elements
| |
GetErrMode |
Returns the current error mode
| |
GetErrStatus |
Returns the current error status
| |
GetFileNode(CvFileStorage, CvFileNode, CvStringHashNode) |
Finds node in the map or file storage
| |
GetFileNode(CvFileStorage, CvFileNode, CvStringHashNode, Boolean) |
Finds node in the map or file storage
| |
GetFileNodeByName |
Finds node in the map or file storage
| |
GetFileNodeName |
Returns name of file node
| |
GetGraphVtx |
Finds graph vertex by index
| |
GetHashedKey(CvFileStorage, String) |
Returns a unique pointer for given name
| |
GetHashedKey(CvFileStorage, String, Boolean) |
Returns a unique pointer for given name
| |
GetHistValue_1D |
Returns pointer to histogram bin.
| |
GetHistValue_2D |
Returns pointer to histogram bin.
| |
GetHistValue_3D |
Returns pointer to histogram bin.
| |
GetHistValue_nD |
Returns pointer to histogram bin.
| |
GetHuMoments |
Calculates seven Hu invariants
| |
GetImage(CvArr) |
Returns image header for arbitrary array
| |
GetImage(CvArr, IplImage) |
Returns image header for arbitrary array
| |
GetImageCOI |
Returns index of channel of interest
| |
GetImageROI |
Returns image ROI coordinates.
The rectangle cvRect(0,0,image.Width,image.Height) is returned if there is no ROI.
| |
GetMat(CvArr) |
Returns matrix header for arbitrary array
| |
GetMat(CvArr, CvMat) |
Returns matrix header for arbitrary array
| |
GetMat(CvArr, CvMat, Int32) |
Returns matrix header for arbitrary array
| |
GetMat(CvArr, CvMat, Int32, Boolean) |
Returns matrix header for arbitrary array
| |
GetMinMaxHistValue(CvHistogram, Single, Single) |
Finds minimum and maximum histogram bins.
| |
GetMinMaxHistValue(CvHistogram, Single, Single, Int32, Int32) |
Finds minimum and maximum histogram bins.
| |
GetModuleInfo |
Retrieves information about the registered module(s) and plugins
| |
GetND |
Return the particular array element
| |
GetNextSparseNode |
Moves iterator to the next sparse matrix element and returns pointer to it.
| |
GetNormalizedCentralMoment |
Retrieves normalized central moment from moment state structure
| |
GetNumThreads |
Returns the current number of threads that are used by parallelized (via OpenMP) OpenCV functions.
| |
GetOptimalDFTSize |
Returns optimal DFT size for given vector size
| |
GetOptimalNewCameraMatrix(CvMat, CvMat, CvSize, Double, CvMat) |
Returns the new camera matrix based on the free scaling parameter
| |
GetOptimalNewCameraMatrix(CvMat, CvMat, CvSize, Double, CvMat, CvSize) |
Returns the new camera matrix based on the free scaling parameter
| |
GetOptimalNewCameraMatrix(CvMat, CvMat, CvSize, Double, CvMat, CvSize, CvRect) |
Returns the new camera matrix based on the free scaling parameter
| |
GetPerspectiveTransform(CvPoint2D32f, CvPoint2D32f) |
Calculates perspective transform from 4 corresponding points.
| |
GetPerspectiveTransform(CvPoint2D32f, CvPoint2D32f, CvMat) |
Calculates perspective transform from 4 corresponding points.
| |
GetQuadrangleSubPix |
Retrieves pixel quadrangle from image with sub-pixel accuracy.
| |
GetRawData(CvArr, IntPtr) |
Retrieves low-level information about the array
| |
GetRawData(CvArr, IntPtr, Int32) |
Retrieves low-level information about the array
| |
GetRawData(CvArr, IntPtr, Int32, CvSize) |
Retrieves low-level information about the array
| |
GetReal1D |
Return the particular element of single-channel array
| |
GetReal2D |
Return the particular element of single-channel array
| |
GetReal3D |
Return the particular element of single-channel array
| |
GetRealND |
Return the particular element of single-channel array
| |
GetRectSubPix |
Retrieves pixel rectangle from image with sub-pixel accuracy.
| |
GetRootFileNode(CvFileStorage) |
Retrieves one of top-level nodes of the file storage
| |
GetRootFileNode(CvFileStorage, Int32) |
Retrieves one of top-level nodes of the file storage
| |
GetRotationMatrix2D |
Calculates affine matrix of 2d rotation.
| |
GetRow |
Returns array row
| |
GetRows(CvArr, CvMat, Int32, Int32) |
Returns array row span
| |
GetRows(CvArr, CvMat, Int32, Int32, Int32) |
Returns array row span
| |
GetSeqElemT(CvSeq, Int32) |
Returns pointer to sequence element by its index
| |
GetSeqElemT(CvSeqT, Int32) |
Returns pointer to sequence element by its index
| |
GetSeqReaderPos |
Returns the current reader position
| |
GetSetElem |
Finds set element by its index
| |
GetSize |
Returns size of matrix or image ROI
| |
GetSpatialMoment |
Retrieves spatial moment from moment state structure
| |
GetStarKeypoints(CvArr, CvMemStorage) |
Retrieves keypoints using the StarDetector algorithm.
| |
GetStarKeypoints(CvArr, CvMemStorage, CvStarDetectorParams) |
Retrieves keypoints using the StarDetector algorithm.
| |
GetSubArr |
Returns matrix header corresponding to the rectangular sub-array of input image or matrix
| |
GetSubRect |
Returns matrix header corresponding to the rectangular sub-array of input image or matrix
| |
GetTextSize |
Retrieves width and height of text string
| |
GetThreadNum |
Returns index of the current thread
| |
GetTickCount |
Returns number of tics starting from some platform-dependent event (number of CPU ticks from the startup, number of milliseconds from 1970th year etc.).
| |
GetTickFrequency |
Returns number of tics per microsecond
| |
GetTrackbarPos |
Returns the current position of the specified trackbar.
| |
GetValidDisparityROI | ||
GetWindowHandle |
Returns native window handle (HWND in case of Win32 and GtkWidget in case of GTK+).
| |
GetWindowName |
Returns the name of window given its native handle (HWND in case of Win32 and GtkWidget in case of GTK+).
| |
GetWindowProperty |
Get Property of the window
| |
GoodFeaturesToTrack(CvArr, CvArr, CvArr, CvPoint2D32f, Int32, Double, Double) |
Determines strong corners on image
| |
GoodFeaturesToTrack(CvArr, CvArr, CvArr, CvPoint2D32f, Int32, Double, Double, CvArr) |
Determines strong corners on image
| |
GoodFeaturesToTrack(CvArr, CvArr, CvArr, CvPoint2D32f, Int32, Double, Double, CvArr, Int32) |
Determines strong corners on image
| |
GoodFeaturesToTrack(CvArr, CvArr, CvArr, CvPoint2D32f, Int32, Double, Double, CvArr, Int32, Boolean) |
Determines strong corners on image
| |
GoodFeaturesToTrack(CvArr, CvArr, CvArr, CvPoint2D32f, Int32, Double, Double, CvArr, Int32, Boolean, Double) |
Determines strong corners on image
| |
GrabFrame |
Grabs the frame from camera or file. The grabbed frame is stored internally.
The purpose of this function is to grab frame fast that is important for syncronization in case of reading from several cameras simultaneously.
The grabbed frames are not exposed because they may be stored in compressed format (as defined by camera/driver).
To retrieve the grabbed frame, cvRetrieveFrame should be used.
| |
GraphAddEdge(CvGraph, Int32, Int32) |
Adds edge to graph
| |
GraphAddEdge(CvGraph, Int32, Int32, CvGraphEdge) |
Adds edge to graph
| |
GraphAddEdge(CvGraph, Int32, Int32, CvGraphEdge, IntPtr) |
Adds edge to graph
| |
GraphAddEdgeByPtr(CvGraph, CvGraphEdge, CvGraphEdge) |
Adds edge to graph
| |
GraphAddEdgeByPtr(CvGraph, CvGraphEdge, CvGraphEdge, CvGraphEdge) |
Adds edge to graph
| |
GraphAddEdgeByPtr(CvGraph, CvGraphEdge, CvGraphEdge, CvGraphEdge, IntPtr) |
Adds edge to graph
| |
GraphAddVtx(CvGraph) |
Adds vertex to graph
| |
GraphAddVtx(CvGraph, CvGraphVtx) |
Adds vertex to graph
| |
GraphAddVtx(CvGraph, CvGraphVtx, CvGraphVtx) |
Adds vertex to graph
| |
GraphEdgeIdx |
Returns index of graph edge
| |
GraphFindEdge |
Finds edge in graph
| |
GraphFindEdgeByPtr |
Finds edge in graph
| |
GraphGetEdgeCount |
Returns count of edges
| |
GraphGetVtxCount |
Returns count of vertex
| |
GraphRemoveEdge |
Removes edge from graph
| |
GraphRemoveEdgeByPtr |
Removes edge from graph
| |
GraphRemoveVtx |
Removes vertex from graph
| |
GraphRemoveVtxByPtr |
Removes vertex from graph
| |
GraphVtxDegree |
Counts edges indicent to the vertex
| |
GraphVtxDegreeByPtr |
Counts edges indicent to the vertex
| |
GraphVtxIdx |
Returns index of graph vertex
| |
HaarDetectObjects(CvArr, CvHaarClassifierCascade, CvMemStorage) |
Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
| |
HaarDetectObjects(CvArr, CvHaarClassifierCascade, CvMemStorage, Double) |
Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
| |
HaarDetectObjects(CvArr, CvHaarClassifierCascade, CvMemStorage, Double, Int32) |
Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
| |
HaarDetectObjects(CvArr, CvHaarClassifierCascade, CvMemStorage, Double, Int32, HaarDetectionType) |
Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
| |
HaarDetectObjects(CvArr, CvHaarClassifierCascade, CvMemStorage, Double, Int32, HaarDetectionType, CvSize, CvSize) |
Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
| |
HoughCircles(CvArr, CvMat, HoughCirclesMethod, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMemStorage, HoughCirclesMethod, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMat, HoughCirclesMethod, Double, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMemStorage, HoughCirclesMethod, Double, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMat, HoughCirclesMethod, Double, Double, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMemStorage, HoughCirclesMethod, Double, Double, Double, Double) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMat, HoughCirclesMethod, Double, Double, Double, Double, Int32) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMemStorage, HoughCirclesMethod, Double, Double, Double, Double, Int32) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMat, HoughCirclesMethod, Double, Double, Double, Double, Int32, Int32) |
Finds circles in grayscale image using Hough transform.
| |
HoughCircles(CvArr, CvMemStorage, HoughCirclesMethod, Double, Double, Double, Double, Int32, Int32) |
Finds circles in grayscale image using Hough transform.
| |
HoughLines2(CvArr, CvMat, HoughLinesMethod, Double, Double, Int32) |
Finds lines in binary image using Hough transform.
| |
HoughLines2(CvArr, CvMemStorage, HoughLinesMethod, Double, Double, Int32) |
Finds lines in binary image using Hough transform.
| |
HoughLines2(CvArr, CvMat, HoughLinesMethod, Double, Double, Int32, Double, Double) |
Finds lines in binary image using Hough transform.
| |
HoughLines2(CvArr, CvMemStorage, HoughLinesMethod, Double, Double, Int32, Double, Double) |
Finds lines in binary image using Hough transform.
| |
IncRefData |
Increments array data reference counter
| |
InitFaceTracker | ||
InitFont(CvFont, FontFace, Double, Double) |
Initializes font structure
| |
InitFont(CvFont, FontFace, Double, Double, Double) |
Initializes font structure
| |
InitFont(CvFont, FontFace, Double, Double, Double, Int32) |
Initializes font structure
| |
InitFont(CvFont, FontFace, Double, Double, Double, Int32, LineType) |
Initializes font structure
| |
InitImageHeader(IplImage, CvSize, BitDepth, Int32) |
Initializes allocated by user image header
| |
InitImageHeader(IplImage, CvSize, BitDepth, Int32, ImageOrigin) |
Initializes allocated by user image header
| |
InitImageHeader(IplImage, CvSize, BitDepth, Int32, ImageOrigin, Int32) |
Initializes allocated by user image header
| |
InitIntrinsicParams2D(CvMat, CvMat, CvMat, CvSize, CvMat) |
Finds the initial camera matrix from the 3D-2D point correspondences
| |
InitIntrinsicParams2D(CvMat, CvMat, CvMat, CvSize, CvMat, Double) |
Finds the initial camera matrix from the 3D-2D point correspondences
| |
InitLineIterator(CvArr, CvPoint, CvPoint, CvLineIterator) |
Initializes line iterator
| |
InitLineIterator(CvArr, CvPoint, CvPoint, CvLineIterator, PixelConnectivity) |
Initializes line iterator
| |
InitLineIterator(CvArr, CvPoint, CvPoint, CvLineIterator, PixelConnectivity, Boolean) |
Initializes line iterator
| |
InitMatHeader(CvMat, Int32, Int32, MatrixType) |
Initializes matrix header.
| |
InitMatHeaderT(CvMat, Int32, Int32, MatrixType, T) |
Initializes matrix header.
| |
InitMatHeaderT(CvMat, Int32, Int32, MatrixType, T, Int32) |
Initializes matrix header.
| |
InitMatNDHeader(CvMatND, Int32, Int32, MatrixType) |
Initializes multi-dimensional array header.
| |
InitMatNDHeaderT(CvMatND, Int32, Int32, MatrixType, T) |
Initializes multi-dimensional array header.
| |
InitSparseMatIterator |
Initializes sparse array elements iterator
| |
InitSubdivDelaunay2D |
CvSubdiv2Dの初期化
| |
InitTreeNodeIteratorT |
Initializes tree node iterator
| |
InitUndistortMap |
Pre-computes the undistortion map - coordinates of the corresponding pixel in the distorted image for every pixel in the corrected image.
| |
InitUndistortRectifyMap |
Computes undistortion+rectification transformation map a head of stereo camera
| |
Inpaint |
Inpaints the selected region in the image.
| |
InRange |
Checks that array elements lie between elements of two other arrays
| |
InRangeS |
Checks that array elements lie between two scalars
| |
InsertNodeIntoTreeT |
Adds new node to the tree
| |
Integral(CvArr, CvArr) |
Calculates integral images.
| |
Integral(CvArr, CvArr, CvArr) |
Calculates integral images.
| |
Integral(CvArr, CvArr, CvArr, CvArr) |
Calculates integral images.
| |
Inv(CvArr, CvArr) |
Finds inverse or pseudo-inverse of matrix
| |
Inv(CvArr, CvArr, InvertMethod) |
Finds inverse or pseudo-inverse of matrix
| |
Invert(CvArr, CvArr) |
Finds inverse or pseudo-inverse of matrix
| |
Invert(CvArr, CvArr, InvertMethod) |
Finds inverse or pseudo-inverse of matrix
| |
InvSqrt |
Calculates inverse square root
| |
IplDepth | ||
IS_GRAPH_EDGE_VISITED(IntPtr) | ||
IS_GRAPH_EDGE_VISITED(CvGraphEdge) | ||
IS_GRAPH_EDGE_VISITED(ICvPtrHolder) | ||
IS_GRAPH_VERTEX_VISITED(IntPtr) | ||
IS_GRAPH_VERTEX_VISITED(CvGraphVtx) | ||
IS_GRAPH_VERTEX_VISITED(ICvPtrHolder) | ||
IS_IMAGE | ||
IS_IMAGE_HDR | ||
IS_MAT(IntPtr) | ||
IS_MAT(ICvPtrHolder) | ||
IS_MAT_HDR | ||
IS_SET_ELEM(IntPtr) | ||
IS_SET_ELEM(CvSetElem) | ||
IS_SET_ELEM(ICvPtrHolder) | ||
IsInf |
Determines if the argument is Infinity
| |
IsNaN |
Determines if the argument is Not A Number
| |
KalmanCorrect |
Adjusts model state
| |
KalmanPredict(CvKalman) |
Estimates subsequent model state
| |
KalmanPredict(CvKalman, CvMat) |
Estimates subsequent model state
| |
KalmanUpdateByMeasurement |
Adjusts model state
| |
KalmanUpdateByTime(CvKalman) |
Estimates subsequent model state
| |
KalmanUpdateByTime(CvKalman, CvMat) |
Estimates subsequent model state
| |
KMeans2(CvArr, Int32, CvArr, CvTermCriteria) |
Splits set of vectors by given number of clusters
| |
KMeans2(Array, MatrixType, Int32, Int32, CvTermCriteria) |
Splits set of vectors by given number of clusters
| |
KMeans2(CvArr, Int32, CvArr, CvTermCriteria, Int32) |
Splits set of vectors by given number of clusters
| |
KMeans2(CvArr, Int32, CvArr, CvTermCriteria, Int32, CvRNG, KMeansFlag) |
Splits set of vectors by given number of clusters
| |
KMeans2(Array, MatrixType, Int32, Int32, CvTermCriteria, Int32, CvRNG, KMeansFlag) |
Splits set of vectors by given number of clusters
| |
KMeans2(CvArr, Int32, CvArr, CvTermCriteria, Int32, CvRNG, KMeansFlag, CvArr) |
Splits set of vectors by given number of clusters
| |
KMeans2(Array, MatrixType, Int32, Int32, CvTermCriteria, Int32, CvRNG, KMeansFlag, CvArr) |
Splits set of vectors by given number of clusters
| |
KMeans2(CvArr, Int32, CvArr, CvTermCriteria, Int32, CvRNG, KMeansFlag, CvArr, Double) |
Splits set of vectors by given number of clusters
| |
KMeans2(Array, MatrixType, Int32, Int32, CvTermCriteria, Int32, CvRNG, KMeansFlag, CvArr, Double) |
Splits set of vectors by given number of clusters
| |
Laplace(CvArr, CvArr) |
Calculates Laplacian of the source image by summing second x- and y- derivatives calculated using Sobel operator.
| |
Laplace(CvArr, CvArr, ApertureSize) |
Calculates Laplacian of the source image by summing second x- and y- derivatives calculated using Sobel operator.
| |
LatentSvmDetectObjects(IplImage, CvLatentSvmDetector, CvMemStorage) |
find rectangular regions in the given image that are likely
to contain objects and corresponding confidence levels
| |
LatentSvmDetectObjects(IplImage, CvLatentSvmDetector, CvMemStorage, Single) |
find rectangular regions in the given image that are likely
to contain objects and corresponding confidence levels
| |
LatentSvmDetectObjects(IplImage, CvLatentSvmDetector, CvMemStorage, Single, Int32) |
find rectangular regions in the given image that are likely
to contain objects and corresponding confidence levels
| |
Line(CvArr, CvPoint, CvPoint, CvScalar) |
Draws a line segment connecting two points
| |
Line(CvArr, CvPoint, CvPoint, CvScalar, Int32) |
Draws a line segment connecting two points
| |
Line(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType) |
Draws a line segment connecting two points
| |
Line(CvArr, Int32, Int32, Int32, Int32, CvScalar) |
Draws a line segment connecting two points
| |
Line(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
Line(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32) |
Draws a line segment connecting two points
| |
Line(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws a line segment connecting two points
| |
Line(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
LinearPolar(CvArr, CvArr, CvPoint2D32f, Double) |
Performs forward or inverse linear-polar image transform
| |
LinearPolar(CvArr, CvArr, CvPoint2D32f, Double, Interpolation) |
Performs forward or inverse linear-polar image transform
| |
LoadT(String) |
Loads object from file
| |
LoadT(String, CvMemStorage) |
Loads object from file
| |
LoadT(String, CvMemStorage, String) |
Loads object from file
| |
LoadT(String, CvMemStorage, String, String) |
Loads object from file
| |
LoadHaarClassifierCascade | Obsolete.
Loads a trained cascade classifier from file or the classifier database embedded in OpenCV
| |
LoadImage(String) |
Loads an image from the specified file and returns the reference to the loaded image.
| |
LoadImage(String, LoadMode) |
Loads an image from the specified file and returns the reference to the loaded image.
| |
LoadImageM(String) |
Loads an image from the specified file and returns the reference to the loaded image as CvMat.
| |
LoadImageM(String, LoadMode) |
Loads an image from the specified file and returns the reference to the loaded image as CvMat.
| |
LoadLatentSvmDetector |
load trained detector from a file
| |
LoadWindowParameters |
Load parameters of the window.
| |
Log |
Calculates natural logarithm of every array element absolute value
| |
LogPolar(CvArr, CvArr, CvPoint2D32f, Double) |
Remaps image to log-polar space.
The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
| |
LogPolar(CvArr, CvArr, CvPoint2D32f, Double, Interpolation) |
Remaps image to log-polar space.
The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
| |
LSHAdd(CvLSH, CvMat) |
Add vectors to the LSH structure, optionally returning indices.
| |
LSHAdd(CvLSH, CvMat, CvMat) |
Add vectors to the LSH structure, optionally returning indices.
| |
LSHQuery |
Query the LSH n times for at most k nearest points; data is n x d,
indices and dist are n x k. At most emax stored points will be accessed.
| |
LSHRemove |
Remove vectors from LSH, as addressed by given indices.
| |
LSHSize |
Return the number of vectors in the LSH.
| |
LUT(CvArr, CvArr, CvArr) |
Performs look-up table transform of array
| |
LUT(CvArr, CvArr, Byte) |
Performs look-up table transform of array
| |
LUT(CvArr, CvArr, Double) |
Performs look-up table transform of array
| |
LUT(CvArr, CvArr, Int16) |
Performs look-up table transform of array
| |
LUT(CvArr, CvArr, Int32) |
Performs look-up table transform of array
| |
LUT(CvArr, CvArr, Single) |
Performs look-up table transform of array
| |
Mahalanobis |
Calculates Mahalanobis distance between two vectors
| |
Mahalonobis |
Calculates Mahalonobis distance between two vectors
| |
MakeHistHeaderForArray(Int32, Int32, CvHistogram, Single) |
Makes a histogram out of array
| |
MakeHistHeaderForArray(Int32, Int32, CvHistogram, Single, Single) |
Makes a histogram out of array
| |
MakeHistHeaderForArray(Int32, Int32, CvHistogram, Single, Single, Boolean) |
Makes a histogram out of array
| |
MakeScanlines |
Calculates scanlines coordinates for two cameras by fundamental matrix
| |
MakeSeqHeaderForArrayT |
Constructs sequence from array
| |
MAKETYPE | ||
Mat(Int32, Int32, MatrixType) |
Initializes matrix header (light-weight variant)
| |
MatT(Int32, Int32, MatrixType, T) |
Initializes matrix header (light-weight variant)
| |
MAT_CN | ||
MAT_DEPTH | ||
MAT_ELEM_PTR | ||
MAT_ELEM_PTR_FAST | ||
MAT_TYPE | ||
MatchContourTrees |
Compares two contours using their tree representations.
| |
MatchShapes(CvArr, CvArr, MatchShapesMethod) |
Compares two shapes.
| |
MatchShapes(CvArr, CvArr, MatchShapesMethod, Double) |
Compares two shapes.
| |
MatchTemplate |
Compares template against overlapped image regions.
| |
MatMul |
Performs generalized matrix multiplication
| |
MatMulAdd |
Performs generalized matrix multiplication
| |
MatMulAddEx(CvArr, CvArr, Double, CvArr, Double, CvArr) |
Performs generalized matrix multiplication
| |
MatMulAddEx(CvArr, CvArr, Double, CvArr, Double, CvArr, GemmOperation) |
Performs generalized matrix multiplication
| |
MatMulAddS(CvArr, CvArr, CvMat) |
Performs matrix transform of every array element
| |
MatMulAddS(CvArr, CvArr, CvMat, CvMat) |
Performs matrix transform of every array element
| |
Max |
Finds per-element maximum of two arrays
| |
MaxRect |
Finds bounding rectangle for two given rectangles
| |
MaxS |
Finds per-element maximum of array and scalar
| |
MeanShift |
Finds object center on back projection
| |
MemStorageAlloc |
Allocates memory buffer in the storage
| |
MemStorageAllocString |
Allocates text string in the storage
| |
Merge |
Composes multi-channel array from several single-channel arrays or inserts a single channel into the array
| |
mGet |
Return the particular element of single-channel floating-point matrix
| |
Min |
Finds per-element minimum of two arrays
| |
MinAreaRect2(CvArr) |
Finds circumscribed rectangle of minimal area for given 2D point set
| |
MinAreaRect2(CvArr, CvMemStorage) |
Finds circumscribed rectangle of minimal area for given 2D point set
| |
MinEnclosingCircle(CvArr, CvPoint2D32f, Single) |
Finds circumscribed rectangle of minimal area for given 2D point set
| |
MinEnclosingCircle(IEnumerableCvPoint, CvPoint2D32f, Single) |
Finds circumscribed rectangle of minimal area for given 2D point set
| |
MinEnclosingCircle(IEnumerableCvPoint2D32f, CvPoint2D32f, Single) |
Finds circumscribed rectangle of minimal area for given 2D point set
| |
MinMaxLoc(CvArr, CvPoint, CvPoint) |
Finds global minimum and maximum in array or subarray
| |
MinMaxLoc(CvArr, Double, Double) |
Finds global minimum and maximum in array or subarray
| |
MinMaxLoc(CvArr, CvPoint, CvPoint, CvArr) |
Finds global minimum and maximum in array or subarray
| |
MinMaxLoc(CvArr, Double, Double, CvArr) |
Finds global minimum and maximum in array or subarray
| |
MinMaxLoc(CvArr, Double, Double, CvPoint, CvPoint) |
Finds global minimum and maximum in array or subarray
| |
MinMaxLoc(CvArr, Double, Double, CvPoint, CvPoint, CvArr) |
Finds global minimum and maximum in array or subarray
| |
MinS |
Finds per-element minimum of array and scalar
| |
Mirror(CvArr) |
Flip a 2D array around vertical, horizontal or both axises
| |
Mirror(CvArr, CvArr) |
Flip a 2D array around vertical, horizontal or both axises
| |
Mirror(CvArr, CvArr, FlipMode) |
Flip a 2D array around vertical, horizontal or both axises
| |
MixChannels |
Copies several channels from input arrays to certain channels of output arrays
| |
Moments |
Moments
| |
MorphologyEx(CvArr, CvArr, CvArr, IplConvKernel, MorphologyOperation) |
Performs advanced morphological transformations using erosion and dilation as basic operations.
| |
MorphologyEx(CvArr, CvArr, CvArr, IplConvKernel, MorphologyOperation, Int32) |
Performs advanced morphological transformations using erosion and dilation as basic operations.
| |
MoveWindow |
Changes position of the window.
| |
MSERParams |
Creates MSER parameters
| |
MSERParams(Int32, Int32, Int32, Single, Single, Int32, Double, Double, Int32) |
Creates MSER parameters
| |
mSet |
Return the particular element of single-channel floating-point matrix
| |
Mul(CvArr, CvArr, CvArr) |
Calculates per-element product of two arrays
| |
Mul(CvArr, CvArr, CvArr, Double) |
Calculates per-element product of two arrays
| |
MulAddS |
Calculates sum of scaled array and another array
| |
MulSpectrums |
Performs per-element multiplication of two Fourier spectrums
| |
MultiplyAcc(CvArr, CvArr, CvArr) |
Adds product of two input images to accumulator
| |
MultiplyAcc(CvArr, CvArr, CvArr, CvArr) |
Adds product of two input images to accumulator
| |
MulTransposed(CvArr, CvArr, Boolean) |
Calculates product of array and transposed array
| |
MulTransposed(CvArr, CvArr, Boolean, CvArr) |
Calculates product of array and transposed array
| |
MulTransposed(CvArr, CvArr, Boolean, CvArr, Double) |
Calculates product of array and transposed array
| |
NamedWindow(String) |
Creates a window which can be used as a placeholder for images and trackbars. Created windows are reffered by their names.
| |
NamedWindow(String, WindowMode) |
Creates a window which can be used as a placeholder for images and trackbars. Created windows are reffered by their names.
| |
NEXT_LINE_POINT | ||
NEXT_SEQ_ELEM | ||
NextGraphItem |
Returns index of graph vertex
| |
NextLinePoint |
Moves iterator to the next line point
| |
NextTreeNode(CvTreeNodeIterator) |
Returns the currently observed node and moves iterator toward the next node
| |
NextTreeNodeT(CvTreeNodeIterator) |
Returns the currently observed node and moves iterator toward the next node
| |
NextTreeNodeT(CvTreeNodeIteratorT) |
Returns the currently observed node and moves iterator toward the next node
| |
NODE_HAS_NAME | ||
NODE_IDX |
CV_NODE_IDX
| |
NODE_IS_COLLECTION | ||
NODE_IS_EMPTY | ||
NODE_IS_FLOW | ||
NODE_IS_INT | ||
NODE_IS_MAP | ||
NODE_IS_REAL | ||
NODE_IS_SEQ | ||
NODE_IS_STRING | ||
NODE_IS_USER | ||
NODE_TYPE | ||
NODE_VAL(CvSparseMat, CvSparseNode) |
CV_NODE_VAL
| |
NODE_VALT(CvSparseMat, CvSparseNode) |
CV_NODE_VAL
| |
Norm(CvArr) |
Calculates absolute array norm, absolute difference norm or relative difference norm
| |
Norm(CvArr, CvArr) |
Calculates absolute array norm, absolute difference norm or relative difference norm
| |
Norm(CvArr, CvArr, NormType) |
Calculates absolute array norm, absolute difference norm or relative difference norm
| |
Norm(CvArr, CvArr, NormType, CvArr) |
Calculates absolute array norm, absolute difference norm or relative difference norm
| |
Normalize(CvArr, CvArr) |
Normalizes array to a certain norm or value range
| |
Normalize(CvArr, CvArr, Double, Double) |
Normalizes array to a certain norm or value range
| |
Normalize(CvArr, CvArr, Double, Double, NormType) |
Normalizes array to a certain norm or value range
| |
Normalize(CvArr, CvArr, Double, Double, NormType, CvArr) |
Normalizes array to a certain norm or value range
| |
NormalizeHist |
Normalizes the histogram bins by scaling them, such that the sum of the bins becomes equal to factor.
| |
Not |
Performs per-element bit-wise inversion of array elements
| |
OpenFileStorage(String, CvMemStorage, FileStorageMode) |
Opens file storage for reading or writing data
| |
OpenFileStorage(String, CvMemStorage, FileStorageMode, String) |
Opens file storage for reading or writing data
| |
Or(CvArr, CvArr, CvArr) |
Calculates per-element bit-wise disjunction of two arrays
| |
Or(CvArr, CvArr, CvArr, CvArr) |
Calculates per-element bit-wise disjunction of two arrays
| |
OrS(CvArr, CvScalar, CvArr) |
Calculates per-element bit-wise disjunction of array and scalar
| |
OrS(CvArr, CvScalar, CvArr, CvArr) |
Calculates per-element bit-wise disjunction of array and scalar
| |
PerspectiveTransform |
Performs perspective matrix transform of vector array
| |
Point |
Creates 2D point with integer coordinates
| |
Point2D32f |
Creates 2D point with floating-point coordinates
| |
Point2D64f |
Creates 2D point with double precision floating-point coordinates
| |
Point3D32f |
Creates3D point with floating-point coordinates
| |
Point3D64f |
Creates 3D point with double precision floating-point coordinates
| |
PointPolygonTest |
Point in contour test
| |
PointSeqFromMat |
Initializes point sequence header from a point vector
| |
PolarToCart(CvArr, CvArr, CvArr, CvArr) |
Calculates cartesian coordinates of 2d vectors represented in polar form
| |
PolarToCart(CvArr, CvArr, CvArr, CvArr, AngleUnit) |
Calculates cartesian coordinates of 2d vectors represented in polar form
| |
PolyLine(CvArr, CvPoint, Boolean, CvScalar) |
Draws simple or thick polygons
| |
PolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32) |
Draws simple or thick polygons
| |
PolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32, LineType) |
Draws simple or thick polygons
| |
PolyLine(CvArr, CvPoint, Boolean, CvScalar, Int32, LineType, Int32) |
Draws simple or thick polygons
| |
POSIT |
Implements POSIT algorithm
| |
PostBoostingFindFace | ||
Pow |
Raises every array element to power
| |
PreCornerDetect(CvArr, CvArr) |
Calculates feature map for corner detection
| |
PreCornerDetect(CvArr, CvArr, ApertureSize) |
Calculates feature map for corner detection
| |
PREV_SEQ_ELEM | ||
PrevTreeNode(CvTreeNodeIterator) |
Returns the currently observed node and moves iterator toward the previous node
| |
PrevTreeNodeT(CvTreeNodeIterator) |
Returns the currently observed node and moves iterator toward the previous node
| |
PrevTreeNodeT(CvTreeNodeIteratorT) |
Returns the currently observed node and moves iterator toward the previous node
| |
ProjectPCA |
Projects vectors to the specified subspace
| |
ProjectPoints2(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
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.
| |
ProjectPoints2(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
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.
| |
ProjectPoints2(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, 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.
| |
Ptr1D(CvArr, Int32) |
Return pointer to the particular array element
| |
Ptr1D(CvArr, Int32, MatrixType) |
Return pointer to the particular array element
| |
Ptr2D(CvArr, Int32, Int32) |
Return pointer to the particular array element
| |
Ptr2D(CvArr, Int32, Int32, MatrixType) |
Return pointer to the particular array element
| |
Ptr3D(CvArr, Int32, Int32, Int32) |
Return pointer to the particular array element
| |
Ptr3D(CvArr, Int32, Int32, Int32, MatrixType) |
Return pointer to the particular array element
| |
PtrND(CvArr, Int32) |
Return pointer to the particular array element
| |
PtrND(CvArr, Int32, MatrixType) |
Return pointer to the particular array element
| |
PtrND(CvArr, Int32, MatrixType, Boolean) |
Return pointer to the particular array element
| |
PtrND(CvArr, Int32, MatrixType, Boolean, NullableUInt32) |
Return pointer to the particular array element
| |
PutText |
Draws text string
| |
PyrDown(CvArr, CvArr) |
Downsamples image.
| |
PyrDown(CvArr, CvArr, CvFilter) |
Downsamples image.
| |
PyrMeanShiftFiltering(CvArr, CvArr, Double, Double) |
Does meanshift image segmentation.
| |
PyrMeanShiftFiltering(CvArr, CvArr, Double, Double, Int32) |
Does meanshift image segmentation.
| |
PyrMeanShiftFiltering(CvArr, CvArr, Double, Double, Int32, CvTermCriteria) |
Does meanshift image segmentation.
| |
PyrSegmentation(IplImage, IplImage, Int32, Double, Double) |
Does image segmentation by pyramids.
| |
PyrSegmentation(IplImage, IplImage, CvMemStorage, CvSeq, Int32, Double, Double) |
Does image segmentation by pyramids.
| |
PyrUp(CvArr, CvArr) |
Upsamples image.
| |
PyrUp(CvArr, CvArr, CvFilter) |
Upsamples image.
| |
QueryFrame |
Grabs a frame from camera or video file, decompresses and returns it.
This function is just a combination of cvGrabFrame and cvRetrieveFrame in one call.
The returned image should not be released or modified by user.
| |
QueryHistValue_1D |
Queries value of histogram bin.
| |
QueryHistValue_2D |
Queries value of histogram bin.
| |
QueryHistValue_3D |
Queries value of histogram bin.
| |
QueryHistValue_nD |
Queries value of histogram bin.
| |
Rand |
Fills array with random numbers
| |
RandArr |
Fills array with random numbers and updates the RNG state
| |
RandInit(CvRandState, Double, Double, Int32) |
Initialize CvRandState structure
| |
RandInit(CvRandState, Double, Double, Int32, DistributionType) |
Initialize CvRandState structure
| |
RandInt |
Returns 32-bit unsigned integer and updates RNG
| |
RandReal |
Returns floating-point random number and updates RNG
| |
RandSetRange(CvRandState, Double, Double) |
Changes RNG range while preserving RNG state
| |
RandSetRange(CvRandState, Double, Double, Int32) |
Changes RNG range while preserving RNG state
| |
RandShuffle(CvArr) |
Randomly shuffles the array elements
| |
RandShuffle(CvArr, CvRNG) |
Randomly shuffles the array elements
| |
RandShuffle(CvArr, CvRNG, Double) |
Randomly shuffles the array elements
| |
Range |
Fills matrix with given range of numbers as following:
arr(i,j) = (end-start) * (i*cols(arr)+j) / (cols(arr)*rows(arr))
| |
RANSACUpdateNumIters |
updates the number of RANSAC iterations
| |
ReadT |
Decodes object and returns pointer to it
| |
READ_SEQ_ELEMT | ||
ReadByNameT |
Finds object and decodes it
| |
ReadChainPoint |
Gets next chain point
| |
ReadInt(CvFileNode) |
Retrieves integer value from file node
| |
ReadInt(CvFileNode, Int32) |
Retrieves integer value from file node
| |
ReadIntByName(CvFileStorage, CvFileNode, String) |
Finds file node and returns its value
| |
ReadIntByName(CvFileStorage, CvFileNode, String, Int32) |
Finds file node and returns its value
| |
ReadRawDataT |
Reads multiple numbers
| |
ReadRawDataSliceT |
Initializes file node sequence reader
| |
ReadReal(CvFileNode) |
Retrieves floating-point value from file node
| |
ReadReal(CvFileNode, Double) |
Retrieves floating-point value from file node
| |
ReadRealByName(CvFileStorage, CvFileNode, String) |
Finds file node and returns its value
| |
ReadRealByName(CvFileStorage, CvFileNode, String, Double) |
Finds file node and returns its value
| |
ReadString(CvFileNode) |
Retrieves text string from file node
| |
ReadString(CvFileNode, String) |
Retrieves text string from file node
| |
ReadStringByName(CvFileStorage, CvFileNode, String) |
Finds file node and returns its value
| |
ReadStringByName(CvFileStorage, CvFileNode, String, String) |
Finds file node and returns its value
| |
RealScalar |
Initializes val[0] with val0, val[1]...val[3] with zeros
| |
Rectangle(CvArr, CvRect, CvScalar) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvPoint, CvPoint, CvScalar) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvRect, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvPoint, CvPoint, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvRect, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvRect, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, Int32, Int32, Int32, Int32, CvScalar) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, CvPoint, CvPoint, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType) |
Draws simple, thick or filled rectangle
| |
Rectangle(CvArr, Int32, Int32, Int32, Int32, CvScalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
RedirectError(IntPtr) |
Sets a new error handler
| |
RedirectError(CvErrorCallback) |
Sets a new error handler
| |
RedirectError(IntPtr, IntPtr, IntPtr) |
Sets a new error handler
| |
RedirectError(CvErrorCallback, IntPtr, IntPtr) |
Sets a new error handler
| |
Reduce(CvArr, CvArr) |
Reduces matrix to a vector
| |
Reduce(CvArr, CvArr, ReduceDimension) |
Reduces matrix to a vector
| |
Reduce(CvArr, CvArr, ReduceDimension, ReduceOperation) |
Reduces matrix to a vector
| |
RegisterType |
Registers new type
| |
Release(IntPtr) |
Releases the object
| |
Release(ICvPtrHolder) |
Releases the object
| |
ReleaseBGCodeBookModel |
Deallocates BGCodeBookModel structure
| |
ReleaseCapture |
Releases the CvCapture structure allocated by cvCreateFileCapture or cvCreateCameraCapture.
| |
ReleaseConDensation |
Deallocates ConDensation filter structure
| |
ReleaseData |
Releases array data.
| |
ReleaseFaceTracker | ||
ReleaseFeatureTree |
Destroys a tree of feature vectors
| |
ReleaseFileStorage |
Releases file storage
| |
ReleaseGraphScanner |
Finishes graph traversal procedure
| |
ReleaseHaarClassifierCascade |
Releases haar classifier cascade
| |
ReleaseHist |
Releases the histogram (header and the data).
| |
ReleaseImage |
Releases header and image data
| |
ReleaseImageHeader |
Releases IplImage header
| |
ReleaseKalman |
Deallocates Kalman filter structure
| |
ReleaseLatentSvmDetector |
release memory allocated for CvLatentSvmDetector structure
| |
ReleaseLSH |
Free the given LSH structure.
| |
ReleaseMat |
Deallocates matrix.
| |
ReleaseMatND(CvMatND) |
Deallocates multi-dimensional array
| |
ReleaseMatND(CvSparseMat) |
Deallocates sparse array
| |
ReleaseMemStorage |
Releases memory storage
| |
ReleasePOSITObject |
Deallocates 3D object structure
| |
ReleasePyramid |
Releases pyramid
| |
ReleaseStereoBMState |
Releases block matching stereo correspondence structure
| |
ReleaseStereoGCState |
Releases the state structure of the graph cut-based stereo correspondence algorithm
| |
ReleaseStructuringElement |
Releases the structure IplConvKernel that is no longer needed.
If *element is NULL, the function has no effect.
| |
ReleaseVideoWriter |
Finishes writing to video file and releases the structure.
| |
Remap(CvArr, CvArr, CvArr, CvArr) |
Applies generic geometrical transformation to the image.
| |
Remap(CvArr, CvArr, CvArr, CvArr, Interpolation) |
Applies generic geometrical transformation to the image.
| |
Remap(CvArr, CvArr, CvArr, CvArr, Interpolation, CvScalar) |
Applies generic geometrical transformation to the image.
| |
RemoveNodeFromTreeT |
Removes node from tree
| |
Repeat |
Fill destination array with tiled source array
| |
ReprojectImageTo3D |
Reprojects disparity image to 3D space
| |
ResetImageROI |
Releases image ROI. After that the whole image is considered selected.
| |
Reshape(CvArr, CvMat, Int32) |
Changes shape of matrix/image without copying data
| |
Reshape(CvArr, CvMat, Int32) |
Changes shape of matrix/image without copying data
| |
Reshape(CvArr, CvMat, Int32, Int32) |
Changes shape of matrix/image without copying data
| |
Reshape(CvArr, CvMat, Int32, Int32) |
Changes shape of matrix/image without copying data
| |
ReshapeMatNDT |
Changes shape of multi-dimensional array w/o copying data
| |
ReshapeNDT |
Changes shape of multi-dimensional array w/o copying data
| |
Resize(CvArr, CvArr) |
Resizes image src so that it fits exactly to dst.
If ROI is set, the function consideres the ROI as supported as usual.
| |
Resize(CvArr, CvArr, Interpolation) |
Resizes image src so that it fits exactly to dst.
If ROI is set, the function consideres the ROI as supported as usual.
| |
ResizeWindow |
Changes size of the window.
| |
RestoreMemStoragePos |
Restores memory storage position
| |
RetrieveFrame(CvCapture) |
Returns the pointer to the image grabbed with cvGrabFrame function.
The returned image should not be released or modified by user.
| |
RetrieveFrame(CvCapture, CameraChannels) |
Returns the pointer to the image grabbed with cvGrabFrame function.
The returned image should not be released or modified by user.
| |
RetrieveFrame(CvCapture, Int32) |
Returns the pointer to the image grabbed with cvGrabFrame function.
The returned image should not be released or modified by user.
| |
REV_READ_SEQ_ELEMT | ||
RGB |
Constructs a color value
| |
RNG |
Initializes random number generator state
| |
RNG(UInt64) |
Initializes random number generator state
| |
Rodrigues2(CvMat, CvMat) |
Converts rotation matrix to rotation vector or vice versa
| |
Rodrigues2(CvMat, CvMat, CvMat) |
Converts rotation matrix to rotation vector or vice versa
| |
Round |
Returns the nearest integer value to the argument.
| |
RQDecomp3x3(CvMat, CvMat, CvMat) |
Computes RQ decomposition for 3x3 matrices
| |
RQDecomp3x3(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
Computes RQ decomposition for 3x3 matrices
| |
RQDecomp3x3(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvPoint3D64f) |
Computes RQ decomposition for 3x3 matrices
| |
RunHaarClassifierCascade(CvHaarClassifierCascade, CvPoint) |
Runs cascade of boosted classifier at given image location
| |
RunHaarClassifierCascade(CvHaarClassifierCascade, CvPoint, Boolean) |
Runs cascade of boosted classifier at given image location
| |
RunningAvg(CvArr, CvArr, Double) |
Calculates weighted sum of input image image and the accumulator acc so that acc becomes a running average of frame sequence:
acc(x,y)=(1-α)•acc(x,y) + α•image(x,y) if mask(x,y)!=null
| |
RunningAvg(CvArr, CvArr, Double, CvArr) |
Calculates weighted sum of input image image and the accumulator acc so that acc becomes a running average of frame sequence:
acc(x,y)=(1-α)•acc(x,y) + α•image(x,y) if mask(x,y)!=null
| |
SampleLine |
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.
| |
Save(String, IntPtr) |
Saves object to file
| |
Save(ICvPtrHolder, String) |
Saves object to file
| |
Save(String, IntPtr, String) |
Saves object to file
| |
Save(ICvPtrHolder, String, String) |
Saves object to file
| |
Save(String, IntPtr, String, String) |
Saves object to file
| |
Save(ICvPtrHolder, String, String, String) |
Saves object to file
| |
Save(String, IntPtr, String, String, CvAttrList) |
Saves object to file
| |
Save(ICvPtrHolder, String, String, String, CvAttrList) |
Saves object to file
| |
SaveImage(String, CvArr, ImageEncodingParam) |
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.
| |
SaveImage(String, CvArr, Int32) |
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.
| |
SaveMemStoragePos |
Saves memory storage position
| |
SaveWindowParameters |
Save parameters of the window.
| |
ScalarAll |
Initializes val[0]...val[3] with val0123
| |
Scale(CvArr, CvArr) |
Converts one array to another with optional linear transformation
| |
Scale(CvArr, CvArr, Double) |
Converts one array to another with optional linear transformation
| |
Scale(CvArr, CvArr, Double, Double) |
Converts one array to another with optional linear transformation
| |
ScaleAdd |
Calculates sum of scaled array and another array
| |
SegmentFGMask(CvArr) | ||
SegmentFGMask(CvArr, Boolean) | ||
SegmentFGMask(CvArr, Boolean, Single) | ||
SegmentFGMask(CvArr, Boolean, Single, CvMemStorage) | ||
SegmentFGMask(CvArr, Boolean, Single, CvMemStorage, CvPoint) | ||
SegmentMotion |
Segments whole motion into separate moving parts
| |
SeqElemIdxT(CvSeq, T) |
Returns index of concrete sequence element
| |
SeqElemIdxT(CvSeq, T, CvSeqBlock) |
Returns index of concrete sequence element
| |
SeqInsertT |
Inserts element in sequence middle
| |
SeqInsertSlice |
Inserts array in the middle of sequence
| |
SeqInvert |
Reverses the order of sequence elements
| |
SeqPartition(CvSeq, CvMemStorage, CvSeq, CvCmpFunc) |
Splits sequence into equivalence classes
| |
SeqPartitionT(CvSeqT, CvMemStorage, CvSeq, CvCmpFuncT) |
Splits sequence into equivalence classes
| |
SeqPop(CvSeq) |
Removes element from sequence end
| |
SeqPopT(CvSeq, T) |
Removes element from sequence end
| |
SeqPopFront(CvSeq) |
Removes element from sequence beginning
| |
SeqPopFrontT(CvSeq, T) |
Removes element from sequence beginning
| |
SeqPopMultiT |
Removes several elements from the either end of sequence
| |
SeqPush(CvSeq) |
allocates a space for one more element.
| |
SeqPushT(CvSeq, T) |
Adds element to sequence end
| |
SeqPushFront(CvSeq) |
Adds element to sequence beginning
| |
SeqPushFrontT(CvSeq, T) |
Adds element to sequence beginning
| |
SeqPushMultiT |
Pushes several elements to the either end of sequence
| |
SeqRemove |
Removes element from sequence middle
| |
SeqRemoveSlice |
Removes sequence slice
| |
SeqSearch(CvSeq, IntPtr, CvCmpFunc, Boolean, Int32) |
Searches element in sequence
| |
SeqSearchT(CvSeq, T, CvCmpFuncT, Boolean, Int32) |
Searches element in sequence
| |
SeqSlice(CvSeq, CvSlice) |
Makes separate header for the sequence slice
| |
SeqSlice(CvSeq, CvSlice, CvMemStorage) |
Makes separate header for the sequence slice
| |
SeqSlice(CvSeq, CvSlice, CvMemStorage, Boolean) |
Makes separate header for the sequence slice
| |
SeqSliceT(CvSeqT, CvSlice) |
Makes separate header for the sequence slice
| |
SeqSliceT(CvSeqT, CvSlice, CvMemStorage) |
Makes separate header for the sequence slice
| |
SeqSliceT(CvSeqT, CvSlice, CvMemStorage, Boolean) |
Makes separate header for the sequence slice
| |
SeqSort(CvSeq, CvCmpFunc) |
Sorts sequence element using the specified comparison function
| |
SeqSortT(CvSeq, CvCmpFuncT) |
Sorts sequence element using the specified comparison function
| |
Set(CvArr, CvScalar) |
Sets every element of array to given value
| |
Set(CvArr, CvScalar, CvArr) |
Sets every element of array to given value
| |
Set1D |
Change the particular array element
| |
Set2D |
Change the particular array element
| |
Set3D |
Change the particular array element
| |
SetAdd(CvSet) |
Occupies a node in the set
| |
SetAdd(CvSet, CvSetElem) |
Occupies a node in the set
| |
SetAdd(CvSet, CvSetElem, CvSetElem) |
Occupies a node in the set
| |
SetCaptureProperty(CvCapture, CaptureProperty, Double) |
Sets the specified property of video capturing.
| |
SetCaptureProperty(CvCapture, Int32, Double) |
Sets the specified property of video capturing.
| |
SetData(CvArr, IntPtr, Int32) |
Assigns user data to the array header.
Header should be initialized before using cvCreate*Header, cvInit*Header or cvMat (in case of matrix) function.
| |
SetDataT(CvArr, T, Int32) |
Assigns user data to the array header.
Header should be initialized before using cvCreate*Header, cvInit*Header or cvMat (in case of matrix) function.
| |
SetErrMode |
Sets error processing mode, returns previously used mode
| |
SetErrStatus |
Sets the error status
| |
SetHistBinRanges(CvHistogram, Single) |
Sets bounds of histogram bins
| |
SetHistBinRanges(CvHistogram, Single, Boolean) |
Sets bounds of histogram bins
| |
SetIdentity(CvArr) |
Initializes scaled identity matrix
| |
SetIdentity(CvArr, CvScalar) |
Initializes scaled identity matrix
| |
SetImageCOI |
Sets channel of interest to given value.
Value 0 means that all channels are selected, 1 means that the first channel is selected etc.
| |
SetImageROI |
Sets image ROI to given rectangle
| |
SetImagesForHaarClassifierCascade |
Assigns images to the hidden cascade
| |
SetMouseCallback |
Sets the callback function for mouse events occuting within the specified window.
| |
SetND |
Change the particular array element
| |
SetNew |
Adds element to set (fast variant)
| |
SetNumThreads |
Sets the number of threads.
| |
SetNumThreads(Int32) |
Sets the number of threads.
| |
SetPostprocessFuncWin32 | ||
SetPreprocessFuncWin32 | ||
SetReal1D |
Change the particular array element
| |
SetReal2D |
Change the particular array element
| |
SetReal3D |
Change the particular array element
| |
SetRealND |
Change the particular array element
| |
SetRemove |
Removes element from set
| |
SetRemoveByPtr |
Removes set element given its pointer
| |
SetSeqBlockSize |
Sets up sequence block size
| |
SetSeqReaderPos(CvSeqReader, Int32) |
Moves the reader to specified position
| |
SetSeqReaderPos(CvSeqReader, Int32, Boolean) |
Moves the reader to specified position
| |
SetTrackbarPos |
Sets the position of the specified trackbar.
| |
SetWindowProperty |
Set Property of the window
| |
SetZero |
Clears the array
| |
ShowImage |
Shows the image in the specified window.
If the window was created with CV_WINDOW_AUTOSIZE flag then the image is shown with its original size, otherwise the image is scaled to fit the window.
| |
Size |
Create CVSize structure and initializes it
| |
SliceLength |
Calculates the sequence slice length
| |
Smooth(CvArr, CvArr) |
Smooths the image in one of several ways.
| |
Smooth(CvArr, CvArr, SmoothType) |
Smooths the image in one of several ways.
| |
Smooth(CvArr, CvArr, SmoothType, Int32) |
Smooths the image in one of several ways.
| |
Smooth(CvArr, CvArr, SmoothType, Int32, Int32) |
Smooths the image in one of several ways.
| |
Smooth(CvArr, CvArr, SmoothType, Int32, Int32, Double) |
Smooths the image in one of several ways.
| |
Smooth(CvArr, CvArr, SmoothType, Int32, Int32, Double, Double) |
Smooths the image in one of several ways.
| |
SnakeImage(IplImage, CvPoint, Single, Single, Single, CvSize, CvTermCriteria) |
Changes contour position to minimize its energy
| |
SnakeImage(IplImage, CvPoint, Single, Single, Single, CvSize, CvTermCriteria) |
Changes contour position to minimize its energy
| |
SnakeImage(IplImage, CvPoint, Single, Single, Single, CvSize, CvTermCriteria, Boolean) |
Changes contour position to minimize its energy
| |
SnakeImage(IplImage, CvPoint, Single, Single, Single, CvSize, CvTermCriteria, Boolean) |
Changes contour position to minimize its energy
| |
Sobel(CvArr, CvArr, Int32, Int32) |
Calculates first, second, third or mixed image derivatives using _extended Sobel operator
| |
Sobel(CvArr, CvArr, Int32, Int32, ApertureSize) |
Calculates first, second, third or mixed image derivatives using extended Sobel operator
| |
Solve(CvArr, CvArr, CvArr) |
Solves linear system or least-squares problem
| |
Solve(CvArr, CvArr, CvArr, InvertMethod) |
Solves linear system or least-squares problem
| |
SolveCubic |
Finds real roots of a cubic equation
| |
SolvePoly(CvMat, CvMat) |
Finds real and complex roots of a polynomial equation with real coefficients
| |
SolvePoly(CvMat, CvMat, Int32) |
Finds real and complex roots of a polynomial equation with real coefficients
| |
SolvePoly(CvMat, CvMat, Int32, Int32) |
Finds real and complex roots of a polynomial equation with real coefficients
| |
Sort(CvArr) |
Sorts the rows/cols of an array ascending/descending
| |
Sort(CvArr, CvArr) |
Sorts the rows/cols of an array ascending/descending
| |
Sort(CvArr, CvArr, CvArr) |
Sorts the rows/cols of an array ascending/descending
| |
Sort(CvArr, CvArr, CvArr, SortFlag) |
Sorts the rows/cols of an array ascending/descending
| |
Split |
Divides multi-channel array into several single-channel arrays or extracts a single channel from the array
| |
Sqrt |
Calculates square root
| |
SquareAcc(CvArr, CvArr) |
Adds the square of source image to accumulator
| |
SquareAcc(CvArr, CvArr, CvArr) |
Adds the square of source image to accumulator
| |
StarDetectorParams |
Constructor
| |
StarDetectorParams(Int32) |
Constructor
| |
StarDetectorParams(Int32, Int32) |
Constructor
| |
StarDetectorParams(Int32, Int32, Int32) |
Constructor
| |
StarDetectorParams(Int32, Int32, Int32, Int32) |
Constructor
| |
StarDetectorParams(Int32, Int32, Int32, Int32, Int32) |
Constructor
| |
StarKeypoint |
Constructor
| |
StartAppendToSeq |
Initializes process of writing data to sequence
| |
StartFindContours(CvArr, CvMemStorage) |
Initializes contour scanning process
| |
StartFindContours(CvArr, CvMemStorage, Int32) |
Initializes contour scanning process
| |
StartFindContours(CvArr, CvMemStorage, Int32, ContourRetrieval) |
Initializes contour scanning process
| |
StartFindContours(CvArr, CvMemStorage, Int32, ContourRetrieval, ContourChain) |
Initializes contour scanning process
| |
StartFindContours(CvArr, CvMemStorage, Int32, ContourRetrieval, ContourChain, CvPoint) |
Initializes contour scanning process
| |
StartNextStream |
Starts the next stream
| |
StartReadChainPoints | ||
StartReadRawData |
Initializes file node sequence reader
| |
StartReadSeq(CvSeq, CvSeqReader) |
Initializes process of sequential reading from sequence
| |
StartReadSeq(CvSeq, CvSeqReader, Boolean) |
Initializes process of sequential reading from sequence
| |
StartWindowThread |
For MacOS or Linux, tries to start thread to hande a window automatically (resizing, updating). Returns 0 if not supported
| |
StartWriteSeq |
Creates new sequence and initializes writer for it
| |
StartWriteStruct(CvFileStorage, String, NodeType) |
Starts writing a new structure
| |
StartWriteStruct(CvFileStorage, String, NodeType, String) |
Starts writing a new structure
| |
StereoCalibrate(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat) |
Calibrates stereo camera
| |
StereoCalibrate(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat) |
Calibrates stereo camera
| |
StereoCalibrate(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat) |
Calibrates stereo camera
| |
StereoCalibrate(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvTermCriteria) |
Calibrates stereo camera
| |
StereoCalibrate(CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvTermCriteria, CalibrationFlag) |
Calibrates stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
Computes rectification transform for stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat) |
Computes rectification transform for stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, StereoRectificationFlag) |
Computes rectification transform for stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, StereoRectificationFlag, Double) |
Computes rectification transform for stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, StereoRectificationFlag, Double, CvSize) |
Computes rectification transform for stereo camera
| |
StereoRectify(CvMat, CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, CvMat, StereoRectificationFlag, Double, CvSize, CvRect, CvRect) |
Computes rectification transform for stereo camera
| |
StereoRectifyUncalibrated(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat) |
Computes rectification transform for uncalibrated stereo camera
| |
StereoRectifyUncalibrated(CvMat, CvMat, CvMat, CvSize, CvMat, CvMat, Double) |
Computes rectification transform for uncalibrated stereo camera
| |
Sub(CvArr, CvArr, CvArr) |
Computes per-element difference between two arrays
| |
Sub(CvArr, CvArr, CvArr, CvArr) |
Computes per-element difference between two arrays
| |
SUBDIV2D_NEXT_EDGE | ||
Subdiv2DEdgeDst |
Returns edge destination.
| |
Subdiv2DEdgeOrg |
Returns edge origin.
| |
Subdiv2DGetEdge |
Returns one of edges related to given.
| |
Subdiv2DLocate(CvSubdiv2D, CvPoint2D32f, CvSubdiv2DEdge) |
Inserts a single point to Delaunay triangulation
| |
Subdiv2DLocate(CvSubdiv2D, CvPoint2D32f, CvSubdiv2DEdge, CvSubdiv2DPoint) |
Inserts a single point to Delaunay triangulation
| |
Subdiv2DNextEdge | ||
Subdiv2DRotateEdge |
Returns another edge of the same quad-edge
| |
Subdiv2DSymEdge | ||
SubdivDelaunay2DInsert |
Inserts a single point to Delaunay triangulation
| |
SubRS(CvArr, CvScalar, CvArr) |
Computes difference between scalar and array
| |
SubRS(CvArr, CvScalar, CvArr, CvArr) |
Computes difference between scalar and array
| |
SubS(CvArr, CvScalar, CvArr) |
Computes difference between array and scalar
| |
SubS(CvArr, CvScalar, CvArr, CvArr) |
Computes difference between array and scalar
| |
SubstituteContour |
Replaces retrieved contour
| |
Sum |
Summarizes array elements
| |
SURFParams |
Creates SURF default parameters
| |
SVBkSb |
Performs singular value back substitution
| |
SVD(CvArr, CvArr) |
Performs singular value decomposition of real floating-point matrix
| |
SVD(CvArr, CvArr, CvArr) |
Performs singular value decomposition of real floating-point matrix
| |
SVD(CvArr, CvArr, CvArr, CvArr) |
Performs singular value decomposition of real floating-point matrix
| |
SVD(CvArr, CvArr, CvArr, CvArr, SVDFlag) |
Performs singular value decomposition of real floating-point matrix
| |
SWAP(Object, Object) | ||
SWAPT(T, T) | ||
T |
Transposes matrix
| |
TermCriteria |
Creates termination criteria for iterative algorithms.
| |
ThreshHist |
Clears histogram bins that are below the specified threshold.
| |
Threshold |
Applies fixed-level threshold to array elements.
| |
Trace |
Returns trace of matrix
| |
TrackFace | ||
Transform(CvArr, CvArr, CvMat) |
Performs matrix transform of every array element
| |
Transform(CvArr, CvArr, CvMat, CvMat) |
Performs matrix transform of every array element
| |
Transpose |
Transposes matrix
| |
TreeToNodeSeqT |
Gathers all node pointers to the single sequence
| |
TriangulatePoints | ||
TypeOf(IntPtr) |
Returns type of the object
| |
TypeOf(ICvPtrHolder) |
Returns type of the object
| |
Undistort2(CvArr, CvArr, CvMat, CvMat) |
Transforms image to compensate lens distortion.
| |
Undistort2(CvArr, CvArr, CvMat, CvMat, CvMat) |
Transforms image to compensate lens distortion.
| |
UndistortPoints |
Computes the ideal point coordinates from the observed point coordinates
| |
UnregisterType |
Unregisters the type
| |
UpdateMotionHistory |
Updates motion history image by moving silhouette
| |
UseOptimized |
Switches between optimized/non-optimized modes
| |
ValidateDisparity(CvArr, CvArr, Int32, Int32) | ||
ValidateDisparity(CvArr, CvArr, Int32, Int32, Int32) | ||
WaitKey |
Waits for key event infinitely (delay<=0) or for "delay" milliseconds.
Returns the code of the pressed key or -1 if no key were pressed until the specified timeout has elapsed.
| |
WaitKey(Int32) |
Waits for key event infinitely (delay<=0) or for "delay" milliseconds.
Returns the code of the pressed key or -1 if no key were pressed until the specified timeout has elapsed.
| |
WarpAffine(CvArr, CvArr, CvMat) |
Applies affine transformation to the image.
| |
WarpAffine(CvArr, CvArr, CvMat, Interpolation) |
Applies affine transformation to the image.
| |
WarpAffine(CvArr, CvArr, CvMat, Interpolation, CvScalar) |
Applies affine transformation to the image.
| |
WarpPerspective(CvArr, CvArr, CvMat) |
Applies perspective transformation to the image.
| |
WarpPerspective(CvArr, CvArr, CvMat, Interpolation) |
Applies perspective transformation to the image.
| |
WarpPerspective(CvArr, CvArr, CvMat, Interpolation, CvScalar) |
Applies perspective transformation to the image.
| |
WarpPerspectiveQMatrix(CvPoint2D32f, CvPoint2D32f) |
Calculates perspective transform from 4 corresponding points.
| |
WarpPerspectiveQMatrix(CvPoint2D32f, CvPoint2D32f, CvMat) |
Calculates perspective transform from 4 corresponding points.
| |
Watershed |
Does watershed segmentation.
| |
Write(CvFileStorage, String, CvArr) |
Writes user object
| |
Write(CvFileStorage, String, CvArr, CvAttrList) |
Writes user object
| |
WRITE_SEQ_ELEMT(T, CvSeqWriter) | ||
WRITE_SEQ_ELEMT(T, CvSeqWriterT) | ||
WRITE_SEQ_ELEM_VAR | ||
WriteComment(CvFileStorage, String) |
Writes comment
| |
WriteComment(CvFileStorage, String, Boolean) |
Writes comment
| |
WriteFileNode |
Writes file node to another file storage
| |
WriteFrame |
Writes/appends one frame to video file.
| |
WriteInt |
Writes an integer value
| |
WriteRawDataT |
Writes multiple numbers
| |
WriteReal |
Writes a floating-point value
| |
WriteString(CvFileStorage, String, String) |
Writes a text string
| |
WriteString(CvFileStorage, String, String, Boolean) |
Writes a text string
| |
Xor(CvArr, CvArr, CvArr) |
Performs per-element bit-wise "exclusive or" operation on two arrays
| |
Xor(CvArr, CvArr, CvArr, CvArr) |
Performs per-element bit-wise "exclusive or" operation on two arrays
| |
XorS(CvArr, CvScalar, CvArr) |
Performs per-element bit-wise "exclusive or" operation on array and scalar
| |
XorS(CvArr, CvScalar, CvArr, CvArr) |
Performs per-element bit-wise "exclusive or" operation on array and scalar
| |
Zero |
Clears the array
|
Fields
Name | Description | |
---|---|---|
AA |
CV_AA
| |
AUTOSTEP |
CV_AUTOSTEP
| |
CV_FOURCC_DEFAULT | ||
CV_FOURCC_PROMPT | ||
CV_MAX_DIM | ||
FILLED |
CV_FILLED
| |
FLOODFILL_FIXED_RANGE |
if set, the difference between the current pixel and seed pixel is considered, otherwise the difference between neighbor pixels is considered (the range is floating)
| |
FLOODFILL_MASK_ONLY |
if set, the function does not fill the image (new_val is ignored), but fills the mask (that must be non-null in this case)
| |
LOG2 |
CV_LOG2
| |
PI |
CV_PI
| |
WHOLE_SEQ |
CV_WHOLE_SEQ
| |
WHOLE_SEQ_END_INDEX |
CV_WHOLE_SEQ_END_INDEX
|
See Also