OpenCV Functions of C++ I/F (cv::xxx)
Inheritance Hierarchy
OpenCvSharp.CPlusPlusCv2
Namespace: OpenCvSharp.CPlusPlus
Assembly: OpenCvSharp.CPlusPlus (in OpenCvSharp.CPlusPlus.dll) Version: 1.0.0.0 (1.0.0.0)
Syntax
The Cv2 type exposes the following members.
Methods
Name | Description | |
---|---|---|
Abs(Mat) |
Computes absolute value of each matrix element
| |
Abs(MatExpr) |
Computes absolute value of each matrix element
| |
Absdiff |
computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
| |
Accumulate |
Adds an image to the accumulator.
| |
AccumulateProduct |
Adds the per-element product of two input images to the accumulator.
| |
AccumulateSquare |
Adds the square of a source image to the accumulator.
| |
AccumulateWeighted |
Updates a running average.
| |
AdaptiveBilateralFilter |
Applies the adaptive bilateral filter to an image.
| |
AdaptiveThreshold |
Applies an adaptive threshold to an array.
| |
Add |
Computes the per-element sum of two arrays or an array and a scalar.
| |
AddWeighted |
computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
| |
AlignSize |
Aligns buffer size by the certain number of bytes
This small inline function aligns a buffer size by
the certian number of bytes by enlarging it.
| |
ApplyColorMap | ||
ApproxPolyDP(IEnumerablePoint, Double, Boolean) |
Approximates contour or a curve using Douglas-Peucker algorithm
| |
ApproxPolyDP(IEnumerablePoint2f, Double, Boolean) |
Approximates contour or a curve using Douglas-Peucker algorithm
| |
ApproxPolyDP(InputArray, OutputArray, Double, Boolean) |
Approximates contour or a curve using Douglas-Peucker algorithm
| |
ArcLength(InputArray, Boolean) |
Calculates a contour perimeter or a curve length.
| |
ArcLength(IEnumerablePoint, Boolean) |
Calculates a contour perimeter or a curve length.
| |
ArcLength(IEnumerablePoint2f, Boolean) |
Calculates a contour perimeter or a curve length.
| |
BatchDistance |
naive nearest neighbor finder
| |
BilateralFilter |
Applies bilateral filter to the image
| |
BitwiseAnd |
computes bitwise conjunction of the two arrays (dst = src1 & src2)
| |
BitwiseNot |
inverts each bit of array (dst = ~src)
| |
BitwiseOr |
computes bitwise disjunction of the two arrays (dst = src1 | src2)
| |
BitwiseXor |
computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
| |
Blur |
Smoothes image using normalized box filter
| |
BoundingRect(InputArray) |
Calculates the up-right bounding rectangle of a point set.
| |
BoundingRect(IEnumerablePoint) |
Calculates the up-right bounding rectangle of a point set.
| |
BoundingRect(IEnumerablePoint2f) |
Calculates the up-right bounding rectangle of a point set.
| |
BoxFilter |
Smoothes image using box filter
| |
BuildOpticalFlowPyramid(InputArray, Mat, Size, Int32, Boolean, BorderType, BorderType, Boolean) |
Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK
| |
BuildOpticalFlowPyramid(InputArray, OutputArray, Size, Int32, Boolean, BorderType, BorderType, Boolean) |
Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK
| |
CalcBackProject |
computes the joint dense histogram for a set of images.
| |
CalcCovarMatrix(InputArray, OutputArray, OutputArray, CovarMatrixFlag) |
computes covariation matrix of a set of samples
| |
CalcCovarMatrix(Mat, Mat, Mat, CovarMatrixFlag) |
computes covariation matrix of a set of samples
| |
CalcCovarMatrix(InputArray, OutputArray, OutputArray, CovarMatrixFlag, MatType) |
computes covariation matrix of a set of samples
| |
CalcCovarMatrix(Mat, Mat, Mat, CovarMatrixFlag, MatType) |
computes covariation matrix of a set of samples
| |
CalcGlobalOrientation |
Computes the global orientation of the selected motion history image part
| |
CalcHist(Mat, Int32, InputArray, OutputArray, Int32, Int32, Rangef, Boolean, Boolean) |
computes the joint dense histogram for a set of images.
| |
CalcHist(Mat, Int32, InputArray, OutputArray, Int32, Int32, Single, Boolean, Boolean) |
computes the joint dense histogram for a set of images.
| |
CalcMotionGradient |
Computes the motion gradient orientation image from the motion history image
| |
CalcOpticalFlowFarneback |
Computes a dense optical flow using the Gunnar Farneback's algorithm.
| |
CalcOpticalFlowPyrLK(InputArray, InputArray, InputArray, InputOutputArray, OutputArray, OutputArray, NullableSize, Int32, NullableTermCriteria, OpticalFlowFlags, Double) |
computes sparse optical flow using multi-scale Lucas-Kanade algorithm
| |
CalcOpticalFlowPyrLK(InputArray, InputArray, Point2f, Point2f, Byte, Single, NullableSize, Int32, NullableTermCriteria, OpticalFlowFlags, Double) |
computes sparse optical flow using multi-scale Lucas-Kanade algorithm
| |
CalcOpticalFlowSF(Mat, Mat, Mat, Int32, Int32, Int32) |
computes dense optical flow using Simple Flow algorithm
| |
CalcOpticalFlowSF(Mat, Mat, Mat, Int32, Int32, Int32, Double, Double, Int32, Double, Double, Double, Int32, Double, Double, Double) |
computes dense optical flow using Simple Flow algorithm
| |
CalibrateCamera(IEnumerableMat, IEnumerableMat, Size, InputOutputArray, InputOutputArray, Mat, Mat, CalibrationFlag, NullableTermCriteria) |
finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
| |
CalibrateCamera(IEnumerableIEnumerablePoint3f, IEnumerableIEnumerablePoint2f, Size, Double, Double, Vec3d, Vec3d, CalibrationFlag, NullableTermCriteria) |
finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
| |
CalibrationMatrixValues(Double, Size, Double, Double, Double, Double, Double, Point2d, Double) |
computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
| |
CalibrationMatrixValues(InputArray, Size, Double, Double, Double, Double, Double, Point2d, Double) |
computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
| |
CamShift |
Finds an object center, size, and orientation.
| |
Canny |
Finds edges in an image using Canny algorithm.
| |
CartToPolar |
converts Cartesian coordinates to polar
| |
ChamferMatching | ||
CheckHardwareSupport | ||
CheckRange(InputArray, Boolean) |
checks that each matrix element is within the specified range.
| |
CheckRange(InputArray, Boolean, Point, Double, Double) |
checks that each matrix element is within the specified range.
| |
Circle(Mat, Point, Int32, Scalar, Int32, LineType, Int32) |
Draws a circle
| |
Circle(Mat, Int32, Int32, Int32, Scalar, Int32, LineType, Int32) |
Draws a circle
| |
ClipLine(Rect, Point, Point) |
Clips the line against the image rectangle
| |
ClipLine(Size, Point, Point) |
Clips the line against the image rectangle
| |
Compare |
compares elements of two arrays (dst = src1 [cmpop] src2)
| |
CompareHist |
compares two histograms stored in dense arrays
| |
CompleteSymm |
extends the symmetrical matrix from the lower half or from the upper half
| |
ComposeRT(Double, Double, Double, Double, Double, Double) |
composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
| |
ComposeRT(Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double, Double) |
composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
| |
ComposeRT(InputArray, InputArray, InputArray, InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray) |
composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
| |
ComputeCorrespondEpilines(IEnumerablePoint2d, Int32, Double) |
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
| |
ComputeCorrespondEpilines(IEnumerablePoint3d, Int32, Double) |
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
| |
ComputeCorrespondEpilines(InputArray, Int32, InputArray, OutputArray) |
For points in an image of a stereo pair, computes the corresponding epilines in the other image.
| |
ContourArea(InputArray, Boolean) |
Calculates the contour area
| |
ContourArea(IEnumerablePoint, Boolean) |
Calculates the contour area
| |
ContourArea(IEnumerablePoint2f, Boolean) |
Calculates the contour area
| |
ConvertImage |
utility function: convert one image to another with optional vertical flip
| |
ConvertMaps | ||
ConvertPointsFromHomogeneous(IEnumerableVec3f) |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
| |
ConvertPointsFromHomogeneous(IEnumerableVec4f) |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
| |
ConvertPointsFromHomogeneous(InputArray, OutputArray) |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
| |
ConvertPointsHomogeneous |
Converts points to/from homogeneous coordinates.
| |
ConvertPointsToHomogeneous(IEnumerableVec2f) |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
| |
ConvertPointsToHomogeneous(IEnumerableVec3f) |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
| |
ConvertPointsToHomogeneous(InputArray, OutputArray) |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
| |
ConvertScaleAbs |
Scales, computes absolute values and converts the result to 8-bit.
| |
ConvexHull(IEnumerablePoint, Boolean) |
Computes convex hull for a set of 2D points.
| |
ConvexHull(IEnumerablePoint2f, Boolean) |
Computes convex hull for a set of 2D points.
| |
ConvexHull(InputArray, OutputArray, Boolean, Boolean) |
Computes convex hull for a set of 2D points.
| |
ConvexHullIndices(IEnumerablePoint, Boolean) |
Computes convex hull for a set of 2D points.
| |
ConvexHullIndices(IEnumerablePoint2f, Boolean) |
Computes convex hull for a set of 2D points.
| |
ConvexityDefects(IEnumerablePoint, IEnumerableInt32) |
Computes the contour convexity defects
| |
ConvexityDefects(IEnumerablePoint2f, IEnumerableInt32) |
Computes the contour convexity defects
| |
ConvexityDefects(InputArray, InputArray, OutputArray) |
Computes the contour convexity defects
| |
CopyMakeBorder |
Forms a border around the image
| |
CornerEigenValsAndVecs |
computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.
| |
CornerSubPix |
adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
| |
CorrectMatches(Double, IEnumerablePoint2d, IEnumerablePoint2d, Point2d, Point2d) |
Refines coordinates of corresponding points.
| |
CorrectMatches(InputArray, InputArray, InputArray, OutputArray, OutputArray) |
Refines coordinates of corresponding points.
| |
CountNonZero |
computes the number of nonzero array elements
| |
CreateCLAHE |
Creates a predefined CLAHE object
| |
CreateFrameSource_Camera | ||
CreateFrameSource_Empty | ||
CreateFrameSource_Video | ||
CreateFrameSource_Video_GPU | ||
CreateHanningWindow |
Computes a Hanning window coefficients in two dimensions.
| |
CreateOptFlow_Brox_GPU | ||
CreateOptFlow_DualTVL1 |
Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
| |
CreateOptFlow_DualTVL1_GPU | ||
CreateOptFlow_DualTVL1_OCL | ||
CreateOptFlow_DualTVL1Ex | ||
CreateOptFlow_Farneback | ||
CreateOptFlow_Farneback_GPU | ||
CreateOptFlow_Farneback_OCL | ||
CreateOptFlow_PyrLK_GPU | ||
CreateOptFlow_PyrLK_OCL | ||
CreateOptFlow_Simple | ||
CreateSuperResolution_BTVL1 |
Create Bilateral TV-L1 Super Resolution.
| |
CreateSuperResolution_BTVL1_GPU |
Create Bilateral TV-L1 Super Resolution.
| |
CreateSuperResolution_BTVL1_OCL |
Create Bilateral TV-L1 Super Resolution.
| |
CubeRoot |
computes cube root of the argument
| |
CvArrToMat | ||
CvtColor |
Converts image from one color space to another
| |
Dct |
Performs forward or inverse 1D or 2D Discrete Cosine Transformation
| |
DecomposeProjectionMatrix(Double, Double, Double, Double) |
Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
| |
DecomposeProjectionMatrix(Double, Double, Double, Double, Double, Double, Double, Double) |
Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
| |
DecomposeProjectionMatrix(InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray) |
Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector
| |
DestroyAllWindows | ||
DestroyWindow | ||
Determinant |
computes determinant of a square matrix
| |
Dft |
Performs a forward Discrete Fourier transform of 1D or 2D floating-point array.
| |
Dilate |
Dilates an image by using a specific structuring element.
| |
DistanceTransform |
computes the distance transform map
| |
DistanceTransformWithLabels |
builds the discrete Voronoi diagram
| |
Divide(Double, InputArray, OutputArray, Int32) |
Performs per-element division of two arrays or a scalar by an array.
| |
Divide(InputArray, InputArray, OutputArray, Double, Int32) |
Performs per-element division of two arrays or a scalar by an array.
| |
DrawChessboardCorners(InputOutputArray, Size, InputArray, Boolean) |
Renders the detected chessboard corners.
| |
DrawChessboardCorners(InputOutputArray, Size, IEnumerablePoint2f, Boolean) |
Renders the detected chessboard corners.
| |
DrawContours(InputOutputArray, IEnumerableMat, Int32, Scalar, Int32, LineType, Mat, Int32, NullablePoint) |
draws contours in the image
| |
DrawContours(InputOutputArray, IEnumerableIEnumerablePoint, Int32, Scalar, Int32, LineType, IEnumerableHierarchyIndex, Int32, NullablePoint) |
draws contours in the image
| |
DrawKeypoints |
Draw keypoints.
| |
DrawMatches(Mat, IEnumerableKeyPoint, Mat, IEnumerableKeyPoint, IEnumerableDMatch, Mat, NullableScalar, NullableScalar, IEnumerableByte, DrawMatchesFlags) |
Draws matches of keypints from two images on output image.
| |
DrawMatches(Mat, IEnumerableKeyPoint, Mat, IEnumerableKeyPoint, IEnumerableIEnumerableDMatch, Mat, NullableScalar, NullableScalar, IEnumerableIEnumerableByte, DrawMatchesFlags) |
Draws matches of keypints from two images on output image.
| |
Eigen(InputArray, OutputArray, Int32, Int32) |
Computes eigenvalues of a symmetric matrix.
| |
Eigen(InputArray, Boolean, OutputArray, OutputArray) |
Computes eigenvalues and eigenvectors of a symmetric matrix.
| |
Eigen(InputArray, OutputArray, OutputArray, Int32, Int32) |
Computes eigenvalues and eigenvectors of a symmetric matrix.
| |
Eigen2x2 | ||
Ellipse(Mat, RotatedRect, Scalar, Int32, LineType) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
Ellipse(Mat, Point, Size, Double, Double, Double, Scalar, Int32, LineType, Int32) |
Draws simple or thick elliptic arc or fills ellipse sector
| |
EMD(InputArray, InputArray, DistanceType) | ||
EMD(InputArray, InputArray, DistanceType, InputArray) | ||
EMD(InputArray, InputArray, DistanceType, InputArray, Single) | ||
EMD(InputArray, InputArray, DistanceType, InputArray, Single, OutputArray) | ||
EqualizeHist |
normalizes the grayscale image brightness and contrast by normalizing its histogram
| |
Erode |
Erodes an image by using a specific structuring element.
| |
EstimateAffine3D |
Computes an optimal affine transformation between two 3D point sets.
| |
EstimateRigidTransform |
Estimates the best-fit Euqcidean, similarity, affine or perspective transformation
that maps one 2D point set to another or one image to another.
| |
Exp(Single) | ||
Exp(InputArray, OutputArray) |
computes exponent of each matrix element (dst = e**src)
| |
ExtractChannel |
extracts a single channel from src (coi is 0-based index)
| |
ExtractImageCOI |
Extract the selected image channel
| |
FAST |
detects corners using FAST algorithm by E. Rosten
| |
FastAtan2(Single, Single) |
computes the angle in degrees (0..360) of the vector (x,y)
| |
FastAtan2(Single, Single, Boolean) | ||
FastFree | ||
FastMalloc | ||
FastNlMeansDenoising |
Perform image denoising using Non-local Means Denoising algorithm
with several computational optimizations. Noise expected to be a gaussian white noise
| |
FastNlMeansDenoisingColored |
Modification of fastNlMeansDenoising function for colored images
| |
FastNlMeansDenoisingColoredMulti(IEnumerableInputArray, OutputArray, Int32, Int32, Single, Single, Int32, Int32) |
Modification of fastNlMeansDenoisingMulti function for colored images sequences
| |
FastNlMeansDenoisingColoredMulti(IEnumerableMat, OutputArray, Int32, Int32, Single, Single, Int32, Int32) |
Modification of fastNlMeansDenoisingMulti function for colored images sequences
| |
FastNlMeansDenoisingMulti(IEnumerableInputArray, OutputArray, Int32, Int32, Single, Int32, Int32) |
Modification of fastNlMeansDenoising function for images sequence where consequtive images have been captured
in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces.
| |
FastNlMeansDenoisingMulti(IEnumerableMat, OutputArray, Int32, Int32, Single, Int32, Int32) |
Modification of fastNlMeansDenoising function for images sequence where consequtive images have been captured
in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces.
| |
FASTX |
detects corners using FAST algorithm by E. Rosten
| |
FillConvexPoly |
Fills a convex polygon.
| |
FillPoly |
Fills the area bounded by one or more polygons
| |
Filter2D |
Convolves an image with the kernel
| |
FilterSpeckles |
filters off speckles (small regions of incorrectly computed disparity)
| |
Find4QuadCornerSubpix(InputArray, InputOutputArray, Size) |
finds subpixel-accurate positions of the chessboard corners
| |
Find4QuadCornerSubpix(InputArray, Point2f, Size) |
finds subpixel-accurate positions of the chessboard corners
| |
FindChessboardCorners(InputArray, Size, OutputArray, ChessboardFlag) |
Finds the positions of internal corners of the chessboard.
| |
FindChessboardCorners(InputArray, Size, Point2f, ChessboardFlag) |
Finds the positions of internal corners of the chessboard.
| |
FindCirclesGrid(InputArray, Size, OutputArray, FindCirclesGridFlag, FeatureDetector) |
Finds centers in the grid of circles.
| |
FindCirclesGrid(InputArray, Size, Point2f, FindCirclesGridFlag, FeatureDetector) |
Finds centers in the grid of circles.
| |
FindContours(InputOutputArray, Mat, OutputArray, ContourRetrieval, ContourChain, NullablePoint) |
Finds contours in a binary image.
| |
FindContours(InputOutputArray, Point, HierarchyIndex, ContourRetrieval, ContourChain, NullablePoint) |
Finds contours in a binary image.
| |
FindContoursAsArray |
Finds contours in a binary image.
| |
FindContoursAsMat |
Finds contours in a binary image.
| |
FindFundamentalMat(InputArray, InputArray, FundamentalMatMethod, Double, Double, OutputArray) |
Calculates a fundamental matrix from the corresponding points in two images.
| |
FindFundamentalMat(IEnumerablePoint2d, IEnumerablePoint2d, FundamentalMatMethod, Double, Double, OutputArray) |
Calculates a fundamental matrix from the corresponding points in two images.
| |
FindHomography(InputArray, InputArray, HomographyMethod, Double, OutputArray) |
computes the best-fit perspective transformation mapping srcPoints to dstPoints.
| |
FindHomography(IEnumerablePoint2d, IEnumerablePoint2d, HomographyMethod, Double, OutputArray) |
computes the best-fit perspective transformation mapping srcPoints to dstPoints.
| |
FindNonZero |
returns the list of locations of non-zero pixels
| |
FitEllipse(InputArray) |
Fits ellipse to the set of 2D points.
| |
FitEllipse(IEnumerablePoint) |
Fits ellipse to the set of 2D points.
| |
FitEllipse(IEnumerablePoint2f) |
Fits ellipse to the set of 2D points.
| |
FitLine(IEnumerablePoint, DistanceType, Double, Double, Double) |
Fits line to the set of 2D points using M-estimator algorithm
| |
FitLine(IEnumerablePoint2f, DistanceType, Double, Double, Double) |
Fits line to the set of 2D points using M-estimator algorithm
| |
FitLine(IEnumerablePoint3f, DistanceType, Double, Double, Double) |
Fits line to the set of 3D points using M-estimator algorithm
| |
FitLine(IEnumerablePoint3i, DistanceType, Double, Double, Double) |
Fits line to the set of 3D points using M-estimator algorithm
| |
FitLine(InputArray, OutputArray, DistanceType, Double, Double, Double) |
Fits line to the set of 2D points using M-estimator algorithm
| |
Flip |
reverses the order of the rows, columns or both in a matrix
| |
FloodFill(InputOutputArray, Point, Scalar) |
Fills a connected component with the given color.
| |
FloodFill(InputOutputArray, InputOutputArray, Point, Scalar) |
Fills a connected component with the given color.
| |
FloodFill(InputOutputArray, Point, Scalar, Rect, NullableScalar, NullableScalar, FloodFillFlag) |
Fills a connected component with the given color.
| |
FloodFill(InputOutputArray, InputOutputArray, Point, Scalar, Rect, NullableScalar, NullableScalar, FloodFillFlag) |
Fills a connected component with the given color.
| |
GaussianBlur |
Blurs an image using a Gaussian filter.
| |
Gemm |
implements generalized matrix product algorithm GEMM from BLAS
| |
GetAffineTransform(InputArray, InputArray) | ||
GetAffineTransform(IEnumerablePoint2f, IEnumerablePoint2f) | ||
GetBuildInformation | ||
GetCpuTickCount | ||
GetDefaultNewCameraMatrix |
returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
| |
GetGaborKernel | ||
GetNumberOfCpus | ||
GetNumThreads | ||
GetOptimalDFTSize |
computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
| |
GetOptimalNewCameraMatrix(Double, Double, Size, Double, Size, Rect, Boolean) |
Returns the new camera matrix based on the free scaling parameter.
| |
GetOptimalNewCameraMatrix(InputArray, InputArray, Size, Double, Size, Rect, Boolean) |
Returns the new camera matrix based on the free scaling parameter.
| |
GetPerspectiveTransform(InputArray, InputArray) | ||
GetPerspectiveTransform(IEnumerablePoint2f, IEnumerablePoint2f) | ||
GetRectSubPix |
Retrieves a pixel rectangle from an image with sub-pixel accuracy.
| |
GetRotationMatrix2D | ||
GetStructuringElement(StructuringElementShape, Size) | ||
GetStructuringElement(StructuringElementShape, Size, Point) | ||
GetTextSize |
returns bounding box of the text string
| |
GetThreadNum | ||
GetTickCount | ||
GetTickFrequency | ||
GetValidDisparityROI |
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
| |
GetWindowProperty |
Provides parameters of a window.
| |
GoodFeaturesToTrack |
finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
| |
GrabCut |
Segments the image using GrabCut algorithm
| |
GroupRectangles(IListRect, Int32, Double) |
Groups the object candidate rectangles.
| |
GroupRectangles(IListRect, Int32, Int32, Double) |
Groups the object candidate rectangles.
| |
GroupRectangles(IListRect, Int32, Double, Int32, Double) |
Groups the object candidate rectangles.
| |
GroupRectangles(IListRect, Int32, Double, Int32, Double) |
Groups the object candidate rectangles.
| |
GroupRectanglesMeanshift | ||
HConcat(Mat, OutputArray) | ||
HConcat(InputArray, InputArray, OutputArray) | ||
HoughCircles |
Finds circles in a grayscale image using a Hough transform.
| |
HoughLines |
Finds lines in a binary image using standard Hough transform.
| |
HoughLinesP |
Finds lines segments in a binary image using probabilistic Hough transform.
| |
Idct |
Performs inverse 1D or 2D Discrete Cosine Transformation
| |
Idft |
Performs an inverse Discrete Fourier transform of 1D or 2D floating-point array.
| |
ImDecode(Byte, LoadMode) |
Reads image from the specified buffer in memory.
| |
ImDecode(Mat, LoadMode) |
Reads image from the specified buffer in memory.
| |
ImEncode(String, InputArray, Byte, ImageEncodingParam) |
Compresses the image and stores it in the memory buffer
| |
ImEncode(String, InputArray, Byte, Int32) |
Compresses the image and stores it in the memory buffer
| |
ImRead |
Loads an image from a file.
| |
ImShow |
Displays the image in the specified window
| |
ImWrite(String, Mat, ImageEncodingParam) |
Saves an image to a specified file.
| |
ImWrite(String, Mat, Int32) |
Saves an image to a specified file.
| |
InitCameraMatrix2D(IEnumerableMat, IEnumerableMat, Size, Double) |
initializes camera matrix from a few 3D points and the corresponding projections.
| |
InitCameraMatrix2D(IEnumerableIEnumerablePoint3d, IEnumerableIEnumerablePoint2d, Size, Double) |
initializes camera matrix from a few 3D points and the corresponding projections.
| |
InitModule_Contrib | ||
InitModule_ML | ||
InitModule_NonFree |
You need to call this method before using SIFT/SURF functions.
| |
InitModule_Video | ||
InitUndistortRectifyMap |
initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
| |
InitWideAngleProjMap |
initializes maps for cv::remap() for wide-angle
| |
Inpaint |
restores the damaged image areas using one of the available intpainting algorithms
| |
InRange(InputArray, InputArray, InputArray, OutputArray) |
set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
| |
InRange(InputArray, Scalar, Scalar, OutputArray) |
set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
| |
InsertChannel |
inserts a single channel to dst (coi is 0-based index)
| |
InsertImageCOI | ||
Integral(InputArray, OutputArray, Int32) | ||
Integral(InputArray, OutputArray, OutputArray, Int32) | ||
Integral(InputArray, OutputArray, OutputArray, OutputArray, Int32) | ||
IntersectConvexConvex(InputArray, InputArray, OutputArray, Boolean) |
finds intersection of two convex polygons
| |
IntersectConvexConvex(IEnumerablePoint, IEnumerablePoint, Point, Boolean) |
finds intersection of two convex polygons
| |
IntersectConvexConvex(IEnumerablePoint2f, IEnumerablePoint2f, Point2f, Boolean) |
finds intersection of two convex polygons
| |
Invert |
computes inverse or pseudo-inverse matrix
| |
InvertAffineTransform |
Inverts an affine transformation.
| |
IsContourConvex(InputArray) |
returns true if the contour is convex.
Does not support contours with self-intersection
| |
IsContourConvex(IEnumerablePoint) |
returns true if the contour is convex.
Does not support contours with self-intersection
| |
IsContourConvex(IEnumerablePoint2f) |
returns true if the contour is convex. D
oes not support contours with self-intersection
| |
Kmeans |
clusters the input data using k-Means algorithm
| |
Laplacian |
Calculates the Laplacian of an image
| |
Line(Mat, Point, Point, Scalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
Line(Mat, Int32, Int32, Int32, Int32, Scalar, Int32, LineType, Int32) |
Draws a line segment connecting two points
| |
Log(Single) | ||
Log(InputArray, OutputArray) |
computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
| |
LUT(InputArray, InputArray, OutputArray, Int32) |
transforms array of numbers using a lookup table: dst(i)=lut(src(i))
| |
LUT(InputArray, Byte, OutputArray, Int32) |
transforms array of numbers using a lookup table: dst(i)=lut(src(i))
| |
Magnitude(Single, Single) | ||
Magnitude(InputArray, InputArray, OutputArray) |
computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
| |
Mahalanobis | ||
Mahalonobis |
computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
| |
MatchShapes(InputArray, InputArray, MatchShapesMethod, Double) |
matches two contours using one of the available algorithms
| |
MatchShapes(IEnumerablePoint, IEnumerablePoint, MatchShapesMethod, Double) |
matches two contours using one of the available algorithms
| |
MatchTemplate |
Computes the proximity map for the raster template and the image where the template is searched for
| |
MatMulDeriv |
computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
| |
Max(InputArray, InputArray, OutputArray) |
computes per-element maximum of two arrays (dst = max(src1, src2))
| |
Max(Mat, Mat, Mat) |
computes per-element maximum of two arrays (dst = max(src1, src2))
| |
Max(Mat, Double, Mat) |
computes per-element maximum of array and scalar (dst = max(src1, src2))
| |
Mean |
computes mean value of selected array elements
| |
MeanShift |
Finds an object on a back projection image.
| |
MeanStdDev(InputArray, OutputArray, OutputArray, InputArray) |
computes mean value and standard deviation of all or selected array elements
| |
MeanStdDev(InputArray, Scalar, Scalar, InputArray) |
computes mean value and standard deviation of all or selected array elements
| |
MedianBlur |
Smoothes image using median filter
| |
Merge |
makes multi-channel array out of several single-channel arrays
| |
Min(InputArray, InputArray, OutputArray) |
computes per-element minimum of two arrays (dst = min(src1, src2))
| |
Min(Mat, Mat, Mat) |
computes per-element minimum of two arrays (dst = min(src1, src2))
| |
Min(Mat, Double, Mat) |
computes per-element minimum of array and scalar (dst = min(src1, src2))
| |
MinAreaRect(InputArray) |
Finds the minimum area rotated rectangle enclosing a 2D point set.
| |
MinAreaRect(IEnumerablePoint) |
Finds the minimum area rotated rectangle enclosing a 2D point set.
| |
MinAreaRect(IEnumerablePoint2f) |
Finds the minimum area rotated rectangle enclosing a 2D point set.
| |
MinEnclosingCircle(InputArray, Point2f, Single) |
Finds the minimum area circle enclosing a 2D point set.
| |
MinEnclosingCircle(IEnumerablePoint, Point2f, Single) |
Finds the minimum area circle enclosing a 2D point set.
| |
MinEnclosingCircle(IEnumerablePoint2f, Point2f, Single) |
Finds the minimum area circle enclosing a 2D point set.
| |
MinMaxIdx(InputArray, Double, Double) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MinMaxIdx(InputArray, Int32, Int32) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MinMaxIdx(InputArray, Double, Double, Int32, Int32, InputArray) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MinMaxLoc(InputArray, Point, Point) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MinMaxLoc(InputArray, Double, Double) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MinMaxLoc(InputArray, Double, Double, Point, Point, InputArray) |
finds global minimum and maximum array elements and returns their values and their locations
| |
MixChannels |
copies selected channels from the input arrays to the selected channels of the output arrays
| |
Moments(Byte, Boolean) |
Calculates all of the moments
up to the third order of a polygon or rasterized shape.
| |
Moments(Single, Boolean) |
Calculates all of the moments
up to the third order of a polygon or rasterized shape.
| |
Moments(InputArray, Boolean) |
Calculates all of the moments
up to the third order of a polygon or rasterized shape.
| |
Moments(IEnumerablePoint, Boolean) |
Calculates all of the moments
up to the third order of a polygon or rasterized shape.
| |
Moments(IEnumerablePoint2f, Boolean) |
Calculates all of the moments
up to the third order of a polygon or rasterized shape.
| |
MorphologyDefaultBorderValue |
Default borderValue for Dilate/Erode
| |
MorphologyEx |
Performs advanced morphological transformations
| |
MoveWindow |
Moves window to the specified position
| |
MulSpectrums |
computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
| |
Multiply |
Calculates the per-element scaled product of two arrays
| |
MulTransposed |
multiplies matrix by its transposition from the left or from the right
| |
NamedWindow(String) |
Creates a window.
| |
NamedWindow(String, WindowMode) |
Creates a window.
| |
Norm(InputArray, NormType, InputArray) |
Calculates absolute array norm, absolute difference norm, or relative difference norm.
| |
Norm(InputArray, InputArray, NormType, InputArray) |
computes norm of selected part of the difference between two arrays
| |
Normalize |
scales and shifts array elements so that either the specified norm (alpha)
or the minimum (alpha) and maximum (beta) array values get the specified values
| |
PatchNaNs |
converts NaN's to the given number
| |
PCABackProject | ||
PCACompute | ||
PCAComputeVar | ||
PCAProject | ||
PerspectiveTransform(IEnumerablePoint2d, Mat) |
performs perspective transformation of each element of multi-channel input matrix
| |
PerspectiveTransform(IEnumerablePoint2f, Mat) |
performs perspective transformation of each element of multi-channel input matrix
| |
PerspectiveTransform(IEnumerablePoint3d, Mat) |
performs perspective transformation of each element of multi-channel input matrix
| |
PerspectiveTransform(IEnumerablePoint3f, Mat) |
performs perspective transformation of each element of multi-channel input matrix
| |
PerspectiveTransform(InputArray, OutputArray, InputArray) |
performs perspective transformation of each element of multi-channel input matrix
| |
Phase |
computes angle (angle(i)) of each (x(i), y(i)) vector
| |
PhaseCorrelate | ||
PhaseCorrelateRes(InputArray, InputArray, InputArray) | ||
PhaseCorrelateRes(InputArray, InputArray, InputArray, Double) | ||
PointPolygonTest(InputArray, Point2f, Boolean) |
Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
| |
PointPolygonTest(IEnumerablePoint, Point2f, Boolean) |
Checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
| |
PointPolygonTest(IEnumerablePoint2f, Point2f, Boolean) |
Checks if the point is inside the contour.
Optionally computes the signed distance from the point to the contour boundary.
| |
PolarToCart |
converts polar coordinates to Cartesian
| |
Polylines |
draws one or more polygonal curves
| |
Pow |
raises the input matrix elements to the specified power (b = a**power)
| |
PreCornerDetect |
computes another complex cornerness criteria at each pixel
| |
ProjectPoints(InputArray, InputArray, InputArray, InputArray, InputArray, OutputArray, OutputArray, Double) |
projects points from the model coordinate space to the image coordinates.
Also computes derivatives of the image coordinates w.r.t the intrinsic
and extrinsic camera parameters
| |
ProjectPoints(IEnumerablePoint3d, Double, Double, Double, Double, Point2d, Double, Double) |
projects points from the model coordinate space to the image coordinates.
Also computes derivatives of the image coordinates w.r.t the intrinsic
and extrinsic camera parameters
| |
PSNR | ||
PutText |
renders text string in the image
| |
PyrDown |
Blurs an image and downsamples it.
| |
PyrMeanShiftFiltering |
Performs initial step of meanshift segmentation of an image.
| |
PyrUp |
Upsamples an image and then blurs it.
| |
Randn(InputOutputArray, InputArray, InputArray) |
fills array with normally-distributed random numbers with the specified mean and the standard deviation
| |
Randn(InputOutputArray, Scalar, Scalar) |
fills array with normally-distributed random numbers with the specified mean and the standard deviation
| |
RandShuffle |
shuffles the input array elements
| |
Randu(InputOutputArray, InputArray, InputArray) |
fills array with uniformly-distributed random numbers from the range [low, high)
| |
Randu(InputOutputArray, Scalar, Scalar) |
fills array with uniformly-distributed random numbers from the range [low, high)
| |
ReadDouble | ||
ReadFloat | ||
ReadInt | ||
ReadKeyPoints | ||
ReadMat | ||
ReadSparseMat | ||
ReadString | ||
Rectangle(Mat, Rect, Scalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
Rectangle(Mat, Point, Point, Scalar, Int32, LineType, Int32) |
Draws simple, thick or filled rectangle
| |
Rectify3Collinear |
computes the rectification transformations for 3-head camera, where all the heads are on the same line.
| |
Reduce |
transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
| |
Remap |
Applies a generic geometrical transformation to an image.
| |
Repeat(Mat, Int32, Int32) |
replicates the input matrix the specified number of times in the horizontal and/or vertical direction
| |
Repeat(InputArray, Int32, Int32, OutputArray) |
replicates the input matrix the specified number of times in the horizontal and/or vertical direction
| |
ReprojectImageTo3D |
reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
| |
Resize |
Resizes an image.
| |
ResizeWindow |
Resizes window to the specified size
| |
Rodrigues(Double, Double) |
converts rotation matrix to rotation vector using Rodrigues transformation
| |
Rodrigues(Double, Double) |
converts rotation vector to rotation matrix using Rodrigues transformation
| |
Rodrigues(Double, Double, Double) |
converts rotation matrix to rotation vector using Rodrigues transformation
| |
Rodrigues(Double, Double, Double) |
converts rotation vector to rotation matrix using Rodrigues transformation
| |
Rodrigues(InputArray, OutputArray, OutputArray) |
converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
| |
RQDecomp3x3(Double, Double, Double) |
Computes RQ decomposition of 3x3 matrix
| |
RQDecomp3x3(Double, Double, Double, Double, Double, Double) |
Computes RQ decomposition of 3x3 matrix
| |
RQDecomp3x3(InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray) |
Computes RQ decomposition of 3x3 matrix
| |
ScaleAdd |
adds scaled array to another one (dst = alpha*src1 + src2)
| |
Scharr |
Calculates the first x- or y- image derivative using Scharr operator
| |
SegmentMotion |
Splits a motion history image into a few parts corresponding to separate independent motions
(for example, left hand, right hand).
| |
SepFilter2D |
Applies separable linear filter to an image
| |
SetIdentity |
initializes scaled identity matrix
| |
SetMouseCallback |
Sets the callback function for mouse events occuting within the specified window.
| |
SetNumThreads | ||
SetUseOptimized |
Turns on/off available optimization.
The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled
or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.
| |
SetWindowProperty(String, WindowProperty, WindowPropertyValue) |
Changes parameters of a window dynamically.
| |
SetWindowProperty(String, WindowProperty, Double) |
Changes parameters of a window dynamically.
| |
Sobel |
Calculates the first, second, third or mixed image derivatives using an extended Sobel operator
| |
Solve |
solves linear system or a least-square problem
| |
SolveCubic |
finds real roots of a cubic polynomial
| |
SolvePnP(InputArray, InputArray, InputArray, InputArray, OutputArray, OutputArray, Boolean, SolvePnPFlag) |
Finds an object pose from 3D-2D point correspondences.
| |
SolvePnP(IEnumerablePoint3f, IEnumerablePoint2f, Double, IEnumerableDouble, Double, Double, Boolean, SolvePnPFlag) |
Finds an object pose from 3D-2D point correspondences.
| |
SolvePnPRansac(IEnumerablePoint3f, IEnumerablePoint2f, Double, IEnumerableDouble, Double, Double) |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
| |
SolvePnPRansac(InputArray, InputArray, InputArray, InputArray, OutputArray, OutputArray, Boolean, Int32, Single, Int32, OutputArray, SolvePnPFlag) |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
| |
SolvePnPRansac(IEnumerablePoint3f, IEnumerablePoint2f, Double, IEnumerableDouble, Double, Double, Int32, Boolean, Int32, Single, Int32, SolvePnPFlag) |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
| |
SolvePoly |
finds real and complex roots of a polynomial
| |
Sort |
sorts independently each matrix row or each matrix column
| |
SortIdx |
sorts independently each matrix row or each matrix column
| |
Split(Mat) |
Copies each plane of a multi-channel array to a dedicated array
| |
Split(Mat, Mat) |
Copies each plane of a multi-channel array to a dedicated array
| |
Sqrt |
computes square root of each matrix element (dst = src**0.5)
| |
StartWindowThread | ||
StereoCalibrate(IEnumerableInputArray, IEnumerableInputArray, IEnumerableInputArray, InputOutputArray, InputOutputArray, InputOutputArray, InputOutputArray, Size, OutputArray, OutputArray, OutputArray, OutputArray, NullableTermCriteria, CalibrationFlag) |
finds intrinsic and extrinsic parameters of a stereo camera
| |
StereoCalibrate(IEnumerableIEnumerablePoint3d, IEnumerableIEnumerablePoint2d, IEnumerableIEnumerablePoint2d, Double, Double, Double, Double, Size, OutputArray, OutputArray, OutputArray, OutputArray, NullableTermCriteria, CalibrationFlag) |
finds intrinsic and extrinsic parameters of a stereo camera
| |
StereoRectify(Double, Double, Double, Double, Size, Double, Double, Double, Double, Double, Double, Double, StereoRectificationFlag, Double, NullableSize) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
| |
StereoRectify(InputArray, InputArray, InputArray, InputArray, Size, InputArray, InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, StereoRectificationFlag, Double, NullableSize) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
| |
StereoRectify(Double, Double, Double, Double, Size, Double, Double, Double, Double, Double, Double, Double, StereoRectificationFlag, Double, Size, Rect, Rect) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
| |
StereoRectify(InputArray, InputArray, InputArray, InputArray, Size, InputArray, InputArray, OutputArray, OutputArray, OutputArray, OutputArray, OutputArray, StereoRectificationFlag, Double, Size, Rect, Rect) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
| |
StereoRectifyUncalibrated(InputArray, InputArray, InputArray, Size, OutputArray, OutputArray, Double) |
computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
| |
StereoRectifyUncalibrated(IEnumerablePoint2d, IEnumerablePoint2d, Double, Size, Double, Double, Double) |
computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
| |
Subtract |
Calculates per-element difference between two arrays or array and a scalar
| |
Sum |
computes sum of array elements
| |
SVBackSubst |
performs back substitution for the previously computed SVD
| |
SVDecomp |
computes SVD of src
| |
TheRNG |
returns the thread-local Random number generator
| |
Threshold |
Applies a fixed-level threshold to each array element.
| |
Trace |
computes trace of a matrix
| |
Transform |
performs affine transformation of each element of multi-channel input matrix
| |
Transpose |
transposes the matrix
| |
TriangulatePoints(Double, Double, IEnumerablePoint2d, IEnumerablePoint2d) |
Reconstructs points by triangulation.
| |
TriangulatePoints(InputArray, InputArray, InputArray, InputArray, OutputArray) |
Reconstructs points by triangulation.
| |
Undistort |
corrects lens distortion for the given camera matrix and distortion coefficients
| |
UndistortPoints |
Computes the ideal point coordinates from the observed point coordinates.
| |
UpdateMotionHistory |
Updates motion history image using the current silhouette
| |
UseOptimized |
Returns the current optimization status.
The function returns the current optimization status, which is controlled by cv::setUseOptimized().
| |
ValidateDisparity |
validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
| |
VConcat(Mat, OutputArray) | ||
VConcat(InputArray, InputArray, OutputArray) | ||
WaitKey |
Waits for a pressed key.
| |
WarpAffine |
Applies an affine transformation to an image.
| |
WarpPerspective(InputArray, OutputArray, InputArray, Size, Interpolation, BorderType, NullableScalar) |
Applies a perspective transformation to an image.
| |
WarpPerspective(InputArray, OutputArray, Single, Size, Interpolation, BorderType, NullableScalar) |
Applies a perspective transformation to an image.
| |
Watershed |
Performs a marker-based image segmentation using the watershed algorithm.
| |
Write(FileStorage, String, Mat) | ||
Write(FileStorage, String, SparseMat) | ||
Write(FileStorage, String, IEnumerableKeyPoint) | ||
Write(FileStorage, String, Double) | ||
Write(FileStorage, String, Int32) | ||
Write(FileStorage, String, Single) | ||
Write(FileStorage, String, String) | ||
WriteScalar(FileStorage, Double) | ||
WriteScalar(FileStorage, Int32) | ||
WriteScalar(FileStorage, Single) | ||
WriteScalar(FileStorage, String) |
Fields
Name | Description | |
---|---|---|
GC_BGD |
GrabCut mask value [background]
| |
GC_FGD |
GrabCut mask value [foreground]
| |
GC_PR_BGD |
GrabCut mask value [most probably background]
| |
GC_PR_FGD |
GrabCut mask value [most probably foreground]
|
See Also