The Image Processing. More...
Go to the source code of this file.
Classes | |
class | cv::BaseRowFilter |
The Base Class for 1D or Row-wise Filters. More... | |
class | cv::BaseColumnFilter |
The Base Class for Column-wise Filters. More... | |
class | cv::BaseFilter |
The Base Class for Non-Separable 2D Filters. More... | |
class | cv::FilterEngine |
The Main Class for Image Filtering. More... | |
class | cv::Moments |
raster image moments More... | |
struct | lsh_hash |
struct | CvLSHOperations |
Namespaces | |
namespace | cv |
Namespace where all the C++ OpenCV functionality resides. | |
Enumerations | |
enum | { cv::BORDER_REPLICATE = IPL_BORDER_REPLICATE, cv::BORDER_CONSTANT = IPL_BORDER_CONSTANT, cv::BORDER_REFLECT = IPL_BORDER_REFLECT, cv::BORDER_WRAP = IPL_BORDER_WRAP, cv::BORDER_REFLECT_101 = IPL_BORDER_REFLECT_101, cv::BORDER_REFLECT101 = BORDER_REFLECT_101, cv::BORDER_TRANSPARENT = IPL_BORDER_TRANSPARENT, cv::BORDER_DEFAULT = BORDER_REFLECT_101, cv::BORDER_ISOLATED = 16 } |
various border interpolation methods More... | |
enum | { cv::KERNEL_GENERAL = 0, cv::KERNEL_SYMMETRICAL = 1, cv::KERNEL_ASYMMETRICAL = 2, cv::KERNEL_SMOOTH = 4, cv::KERNEL_INTEGER = 8 } |
type of the kernel More... | |
enum | { cv::MORPH_ERODE = CV_MOP_ERODE, cv::MORPH_DILATE = CV_MOP_DILATE, cv::MORPH_OPEN = CV_MOP_OPEN, cv::MORPH_CLOSE = CV_MOP_CLOSE, cv::MORPH_GRADIENT = CV_MOP_GRADIENT, cv::MORPH_TOPHAT = CV_MOP_TOPHAT, cv::MORPH_BLACKHAT = CV_MOP_BLACKHAT } |
type of morphological operation More... | |
enum | { cv::MORPH_RECT = 0, cv::MORPH_CROSS = 1, cv::MORPH_ELLIPSE = 2 } |
shape of the structuring element More... | |
enum | { cv::INTER_NEAREST = CV_INTER_NN, cv::INTER_LINEAR = CV_INTER_LINEAR, cv::INTER_CUBIC = CV_INTER_CUBIC, cv::INTER_AREA = CV_INTER_AREA, cv::INTER_LANCZOS4 = CV_INTER_LANCZOS4, cv::INTER_MAX = 7, cv::WARP_INVERSE_MAP = CV_WARP_INVERSE_MAP } |
interpolation algorithm More... | |
enum | { cv::INTER_BITS = 5, cv::INTER_BITS2 = INTER_BITS*2, cv::INTER_TAB_SIZE = (1<<INTER_BITS), cv::INTER_TAB_SIZE2 = INTER_TAB_SIZE*INTER_TAB_SIZE } |
enum | { cv::THRESH_BINARY = CV_THRESH_BINARY, cv::THRESH_BINARY_INV = CV_THRESH_BINARY_INV, cv::THRESH_TRUNC = CV_THRESH_TRUNC, cv::THRESH_TOZERO = CV_THRESH_TOZERO, cv::THRESH_TOZERO_INV = CV_THRESH_TOZERO_INV, cv::THRESH_MASK = CV_THRESH_MASK, cv::THRESH_OTSU = CV_THRESH_OTSU } |
type of the threshold operation More... | |
enum | { cv::ADAPTIVE_THRESH_MEAN_C = 0, cv::ADAPTIVE_THRESH_GAUSSIAN_C = 1 } |
adaptive threshold algorithm More... | |
enum | { cv::PROJ_SPHERICAL_ORTHO = 0, cv::PROJ_SPHERICAL_EQRECT = 1 } |
enum | { cv::GC_BGD = 0, cv::GC_FGD = 1, cv::GC_PR_BGD = 2, cv::GC_PR_FGD = 3 } |
class of the pixel in GrabCut algorithm More... | |
enum | { cv::GC_INIT_WITH_RECT = 0, cv::GC_INIT_WITH_MASK = 1, cv::GC_EVAL = 2 } |
GrabCut algorithm flags. More... | |
enum | { cv::INPAINT_NS = CV_INPAINT_NS, cv::INPAINT_TELEA = CV_INPAINT_TELEA } |
the inpainting algorithm More... | |
enum | { cv::FLOODFILL_FIXED_RANGE = 1 << 16, cv::FLOODFILL_MASK_ONLY = 1 << 17 } |
enum | { cv::TM_SQDIFF = 0, cv::TM_SQDIFF_NORMED = 1, cv::TM_CCORR = 2, cv::TM_CCORR_NORMED = 3, cv::TM_CCOEFF = 4, cv::TM_CCOEFF_NORMED = 5 } |
type of the template matching operation More... | |
enum | { cv::RETR_EXTERNAL = CV_RETR_EXTERNAL, cv::RETR_LIST = CV_RETR_LIST, cv::RETR_CCOMP = CV_RETR_CCOMP, cv::RETR_TREE = CV_RETR_TREE } |
mode of the contour retrieval algorithm More... | |
enum | { cv::CHAIN_APPROX_NONE = CV_CHAIN_APPROX_NONE, cv::CHAIN_APPROX_SIMPLE = CV_CHAIN_APPROX_SIMPLE, cv::CHAIN_APPROX_TC89_L1 = CV_CHAIN_APPROX_TC89_L1, cv::CHAIN_APPROX_TC89_KCOS = CV_CHAIN_APPROX_TC89_KCOS } |
the contour approximation algorithm More... | |
Functions | |
CV_EXPORTS_W int | cv::borderInterpolate (int p, int len, int borderType) |
1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. | |
CV_EXPORTS int | cv::getKernelType (InputArray kernel, Point anchor) |
returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. | |
CV_EXPORTS Ptr< BaseRowFilter > | cv::getLinearRowFilter (int srcType, int bufType, InputArray kernel, int anchor, int symmetryType) |
returns the primitive row filter with the specified kernel | |
CV_EXPORTS Ptr< BaseColumnFilter > | cv::getLinearColumnFilter (int bufType, int dstType, InputArray kernel, int anchor, int symmetryType, double delta=0, int bits=0) |
returns the primitive column filter with the specified kernel | |
CV_EXPORTS Ptr< BaseFilter > | cv::getLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) |
returns 2D filter with the specified kernel | |
CV_EXPORTS Ptr< FilterEngine > | cv::createSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point _anchor=Point(-1,-1), double delta=0, int _rowBorderType=BORDER_DEFAULT, int _columnBorderType=-1, const Scalar &_borderValue=Scalar()) |
returns the separable linear filter engine | |
CV_EXPORTS Ptr< FilterEngine > | cv::createLinearFilter (int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int _rowBorderType=BORDER_DEFAULT, int _columnBorderType=-1, const Scalar &_borderValue=Scalar()) |
returns the non-separable linear filter engine | |
CV_EXPORTS_W Mat | cv::getGaussianKernel (int ksize, double sigma, int ktype=CV_64F) |
returns the Gaussian kernel with the specified parameters | |
CV_EXPORTS Ptr< FilterEngine > | cv::createGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT) |
returns the Gaussian filter engine | |
CV_EXPORTS_W void | cv::getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F) |
initializes kernels of the generalized Sobel operator | |
CV_EXPORTS Ptr< FilterEngine > | cv::createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT) |
returns filter engine for the generalized Sobel operator | |
CV_EXPORTS Ptr< BaseRowFilter > | cv::getRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1) |
returns horizontal 1D box filter | |
CV_EXPORTS Ptr< BaseColumnFilter > | cv::getColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1) |
returns vertical 1D box filter | |
CV_EXPORTS Ptr< FilterEngine > | cv::createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
returns box filter engine | |
CV_EXPORTS Ptr< BaseRowFilter > | cv::getMorphologyRowFilter (int op, int type, int ksize, int anchor=-1) |
returns horizontal 1D morphological filter | |
CV_EXPORTS Ptr< BaseColumnFilter > | cv::getMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1) |
returns vertical 1D morphological filter | |
CV_EXPORTS Ptr< BaseFilter > | cv::getMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1)) |
returns 2D morphological filter | |
CV_EXPORTS Ptr< FilterEngine > | cv::createMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1), int _rowBorderType=BORDER_CONSTANT, int _columnBorderType=-1, const Scalar &_borderValue=morphologyDefaultBorderValue()) |
returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. | |
CV_EXPORTS_W Mat | cv::getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1)) |
returns structuring element of the specified shape and size | |
CV_EXPORTS_W void | cv::copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar()) |
copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode | |
CV_EXPORTS_W void | cv::medianBlur (InputArray src, OutputArray dst, int ksize) |
smooths the image using median filter. | |
CV_EXPORTS_W void | cv::GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT) |
smooths the image using Gaussian filter. | |
CV_EXPORTS_W void | cv::bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT) |
smooths the image using bilateral filter | |
CV_EXPORTS_W void | cv::boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
smooths the image using the box filter. Each pixel is processed in O(1) time | |
CV_EXPORTS_W void | cv::blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT) |
a synonym for normalized box filter | |
CV_EXPORTS_W void | cv::filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
applies non-separable 2D linear filter to the image | |
CV_EXPORTS_W void | cv::sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
applies separable 2D linear filter to the image | |
CV_EXPORTS_W void | cv::Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
applies generalized Sobel operator to the image | |
CV_EXPORTS_W void | cv::Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
applies the vertical or horizontal Scharr operator to the image | |
CV_EXPORTS_W void | cv::Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
applies Laplacian operator to the image | |
CV_EXPORTS_W void | cv::Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false) |
applies Canny edge detector and produces the edge map. | |
CV_EXPORTS_W void | cv::cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT) |
computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria | |
CV_EXPORTS_W void | cv::cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT) |
computes Harris cornerness criteria at each image pixel | |
CV_EXPORTS_W void | cv::cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT) |
computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix. | |
CV_EXPORTS_W void | cv::preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT) |
computes another complex cornerness criteria at each pixel | |
CV_EXPORTS void | cv::cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria) |
adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria | |
CV_EXPORTS_W void | cv::goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04) |
finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima | |
CV_EXPORTS_W void | cv::HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0) |
finds lines in the black-n-white image using the standard or pyramid Hough transform | |
CV_EXPORTS_W void | cv::HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0) |
finds line segments in the black-n-white image using probabalistic Hough transform | |
CV_EXPORTS_W void | cv::HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0) |
finds circles in the grayscale image using 2+1 gradient Hough transform | |
CV_EXPORTS_W void | cv::erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
erodes the image (applies the local minimum operator) | |
CV_EXPORTS_W void | cv::dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
dilates the image (applies the local maximum operator) | |
CV_EXPORTS_W void | cv::morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
applies an advanced morphological operation to the image | |
CV_EXPORTS_W void | cv::resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR) |
resizes the image | |
CV_EXPORTS_W void | cv::warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using affine transformation | |
CV_EXPORTS_W void | cv::warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using perspective transformation | |
CV_EXPORTS_W void | cv::remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format | |
CV_EXPORTS_W void | cv::convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false) |
converts maps for remap from floating-point to fixed-point format or backwards | |
CV_EXPORTS_W Mat | cv::getRotationMatrix2D (Point2f center, double angle, double scale) |
returns 2x3 affine transformation matrix for the planar rotation. | |
CV_EXPORTS Mat | cv::getPerspectiveTransform (const Point2f src[], const Point2f dst[]) |
returns 3x3 perspective transformation for the corresponding 4 point pairs. | |
CV_EXPORTS Mat | cv::getAffineTransform (const Point2f src[], const Point2f dst[]) |
returns 2x3 affine transformation for the corresponding 3 point pairs. | |
CV_EXPORTS_W void | cv::invertAffineTransform (InputArray M, OutputArray iM) |
computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. | |
CV_EXPORTS_W void | cv::getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1) |
extracts rectangle from the image at sub-pixel location | |
CV_EXPORTS_W void | cv::integral (InputArray src, OutputArray sum, int sdepth=-1) |
computes the integral image | |
cv::CV_EXPORTS_AS (integral2) void integral(InputArray src | |
computes the integral image and integral for the squared image | |
cv::CV_EXPORTS_AS (integral3) void integral(InputArray src | |
computes the integral image, integral for the squared image and the tilted integral image | |
CV_EXPORTS_W void | cv::accumulate (InputArray src, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray()) |
adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. | |
CV_EXPORTS_W void | cv::accumulateSquare (InputArray src, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray()) |
adds squared src image to the accumulator (dst += src*src). | |
CV_EXPORTS_W void | cv::accumulateProduct (InputArray src1, InputArray src2, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray()) |
adds product of the 2 images to the accumulator (dst += src1*src2). | |
CV_EXPORTS_W void | cv::accumulateWeighted (InputArray src, CV_IN_OUT InputOutputArray dst, double alpha, InputArray mask=noArray()) |
updates the running average (dst = dst*(1-alpha) + src*alpha) | |
CV_EXPORTS_W double | cv::threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type) |
applies fixed threshold to the image | |
CV_EXPORTS_W void | cv::adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) |
applies variable (adaptive) threshold to the image | |
CV_EXPORTS_W void | cv::pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size()) |
smooths and downsamples the image | |
CV_EXPORTS_W void | cv::pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size()) |
upsamples and smoothes the image | |
CV_EXPORTS void | cv::buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel) |
builds the gaussian pyramid using pyrDown() as a basic operation | |
CV_EXPORTS_W void | cv::undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray()) |
corrects lens distortion for the given camera matrix and distortion coefficients | |
CV_EXPORTS_W void | cv::initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2) |
initializes maps for cv::remap() to correct lens distortion and optionally rectify the image | |
CV_EXPORTS_W float | cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0) |
initializes maps for cv::remap() for wide-angle | |
CV_EXPORTS_W Mat | cv::getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false) |
returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true) | |
CV_EXPORTS void | cv::undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) |
returns points' coordinates after lens distortion correction | |
CV_EXPORTS void | cv::calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
computes the joint dense histogram for a set of images. | |
CV_EXPORTS void | cv::calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
computes the joint sparse histogram for a set of images. | |
CV_EXPORTS void | cv::calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
computes back projection for the set of images | |
CV_EXPORTS void | cv::calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
computes back projection for the set of images | |
CV_EXPORTS_W double | cv::compareHist (InputArray H1, InputArray H2, int method) |
compares two histograms stored in dense arrays | |
CV_EXPORTS double | cv::compareHist (const SparseMat &H1, const SparseMat &H2, int method) |
compares two histograms stored in sparse arrays | |
CV_EXPORTS_W void | cv::equalizeHist (InputArray src, OutputArray dst) |
normalizes the grayscale image brightness and contrast by normalizing its histogram | |
CV_EXPORTS float | cv::EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray()) |
CV_EXPORTS_W void | cv::watershed (InputArray image, InputOutputArray markers) |
segments the image using watershed algorithm | |
CV_EXPORTS_W void | cv::pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)) |
filters image using meanshift algorithm | |
CV_EXPORTS_W void | cv::grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL) |
segments the image using GrabCut algorithm | |
CV_EXPORTS_W void | cv::inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRange, int flags) |
restores the damaged image areas using one of the available intpainting algorithms | |
CV_EXPORTS_W void | cv::distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize) |
builds the discrete Voronoi diagram | |
CV_EXPORTS void | cv::distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize) |
computes the distance transform map | |
CV_EXPORTS int | cv::floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
fills the semi-uniform image region starting from the specified seed point | |
CV_EXPORTS_W int | cv::floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
fills the semi-uniform image region and/or the mask starting from the specified seed point | |
CV_EXPORTS_W void | cv::cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0) |
converts image from one color space to another | |
CV_EXPORTS_W Moments | cv::moments (InputArray array, bool binaryImage=false) |
computes moments of the rasterized shape or a vector of points | |
CV_EXPORTS void | cv::HuMoments (const Moments &moments, double hu[7]) |
computes 7 Hu invariants from the moments | |
CV_EXPORTS_W void | cv::matchTemplate (InputArray image, InputArray templ, OutputArray result, int method) |
computes the proximity map for the raster template and the image where the template is searched for | |
CV_EXPORTS void | cv::findContours (InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) |
retrieves contours and the hierarchical information from black-n-white image. | |
CV_EXPORTS void | cv::findContours (InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) |
retrieves contours from black-n-white image. | |
CV_EXPORTS void | cv::drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point()) |
draws contours in the image | |
CV_EXPORTS void | cv::approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed) |
approximates contour or a curve using Douglas-Peucker algorithm | |
CV_EXPORTS_W double | cv::arcLength (InputArray curve, bool closed) |
computes the contour perimeter (closed=true) or a curve length | |
CV_EXPORTS_W Rect | cv::boundingRect (InputArray points) |
computes the bounding rectangle for a contour | |
CV_EXPORTS_W double | cv::contourArea (InputArray contour, bool oriented=false) |
computes the contour area | |
CV_EXPORTS_W RotatedRect | cv::minAreaRect (InputArray points) |
computes the minimal rotated rectangle for a set of points | |
CV_EXPORTS_W void | cv::minEnclosingCircle (InputArray points, Point2f ¢er, float &radius) |
computes the minimal enclosing circle for a set of points | |
CV_EXPORTS_W double | cv::matchShapes (InputArray contour1, InputArray contour2, int method, double parameter) |
matches two contours using one of the available algorithms | |
CV_EXPORTS void | cv::convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true) |
computes convex hull for a set of 2D points. | |
CV_EXPORTS_W bool | cv::isContourConvex (InputArray contour) |
returns true iff the contour is convex. Does not support contours with self-intersection | |
CV_EXPORTS_W RotatedRect | cv::fitEllipse (InputArray points) |
fits ellipse to the set of 2D points | |
CV_EXPORTS void | cv::fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps) |
fits line to the set of 2D points using M-estimator algorithm | |
CV_EXPORTS_W double | cv::pointPolygonTest (InputArray contour, Point2f pt, bool measureDist) |
checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary | |
Variables | |
OutputArray | cv::sum |
OutputArray OutputArray | cv::sqsum |
OutputArray OutputArray int | cv::sdepth = -1 ) |
OutputArray OutputArray OutputArray | cv::tilted |
The Image Processing.