OpenCV for Unity  2.6.0
Enox Software / Please refer to OpenCV official document ( http://docs.opencv.org/4.9.0/index.html ) for the details of the argument of the method.
Static Public Member Functions | Public Attributes | List of all members
OpenCVForUnity.ImgprocModule.Imgproc Class Reference

Static Public Member Functions

static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale, double quant, double ang_th, double log_eps, double density_th, int n_bins)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale, double quant, double ang_th, double log_eps, double density_th)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale, double quant, double ang_th, double log_eps)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale, double quant, double ang_th)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale, double quant)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale, double sigma_scale)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine, double scale)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector (int refine)
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static LineSegmentDetector createLineSegmentDetector ()
 Creates a smart pointer to a LineSegmentDetector object and initializes it. More...
 
static Mat getGaussianKernel (int ksize, double sigma, int ktype)
 Returns Gaussian filter coefficients. More...
 
static Mat getGaussianKernel (int ksize, double sigma)
 Returns Gaussian filter coefficients. More...
 
static void getDerivKernels (Mat kx, Mat ky, int dx, int dy, int ksize, bool normalize, int ktype)
 Returns filter coefficients for computing spatial image derivatives. More...
 
static void getDerivKernels (Mat kx, Mat ky, int dx, int dy, int ksize, bool normalize)
 Returns filter coefficients for computing spatial image derivatives. More...
 
static void getDerivKernels (Mat kx, Mat ky, int dx, int dy, int ksize)
 Returns filter coefficients for computing spatial image derivatives. More...
 
static Mat getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype)
 Returns Gabor filter coefficients. More...
 
static Mat getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi)
 Returns Gabor filter coefficients. More...
 
static Mat getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma)
 Returns Gabor filter coefficients. More...
 
static Mat getStructuringElement (int shape, Size ksize, Point anchor)
 Returns a structuring element of the specified size and shape for morphological operations. More...
 
static Mat getStructuringElement (int shape, Size ksize)
 Returns a structuring element of the specified size and shape for morphological operations. More...
 
static void medianBlur (Mat src, Mat dst, int ksize)
 Blurs an image using the median filter. More...
 
static void GaussianBlur (Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY, int borderType)
 Blurs an image using a Gaussian filter. More...
 
static void GaussianBlur (Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY)
 Blurs an image using a Gaussian filter. More...
 
static void GaussianBlur (Mat src, Mat dst, Size ksize, double sigmaX)
 Blurs an image using a Gaussian filter. More...
 
static void bilateralFilter (Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)
 Applies the bilateral filter to an image. More...
 
static void bilateralFilter (Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)
 Applies the bilateral filter to an image. More...
 
static void boxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor, bool normalize, int borderType)
 Blurs an image using the box filter. More...
 
static void boxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor, bool normalize)
 Blurs an image using the box filter. More...
 
static void boxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor)
 Blurs an image using the box filter. More...
 
static void boxFilter (Mat src, Mat dst, int ddepth, Size ksize)
 Blurs an image using the box filter. More...
 
static void sqrBoxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor, bool normalize, int borderType)
 Calculates the normalized sum of squares of the pixel values overlapping the filter. More...
 
static void sqrBoxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor, bool normalize)
 Calculates the normalized sum of squares of the pixel values overlapping the filter. More...
 
static void sqrBoxFilter (Mat src, Mat dst, int ddepth, Size ksize, Point anchor)
 Calculates the normalized sum of squares of the pixel values overlapping the filter. More...
 
static void sqrBoxFilter (Mat src, Mat dst, int ddepth, Size ksize)
 Calculates the normalized sum of squares of the pixel values overlapping the filter. More...
 
static void blur (Mat src, Mat dst, Size ksize, Point anchor, int borderType)
 Blurs an image using the normalized box filter. More...
 
static void blur (Mat src, Mat dst, Size ksize, Point anchor)
 Blurs an image using the normalized box filter. More...
 
static void blur (Mat src, Mat dst, Size ksize)
 Blurs an image using the normalized box filter. More...
 
static void stackBlur (Mat src, Mat dst, Size ksize)
 Blurs an image using the stackBlur. More...
 
static void filter2D (Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta, int borderType)
 Convolves an image with the kernel. More...
 
static void filter2D (Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta)
 Convolves an image with the kernel. More...
 
static void filter2D (Mat src, Mat dst, int ddepth, Mat kernel, Point anchor)
 Convolves an image with the kernel. More...
 
static void filter2D (Mat src, Mat dst, int ddepth, Mat kernel)
 Convolves an image with the kernel. More...
 
static void sepFilter2D (Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta, int borderType)
 Applies a separable linear filter to an image. More...
 
static void sepFilter2D (Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta)
 Applies a separable linear filter to an image. More...
 
static void sepFilter2D (Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor)
 Applies a separable linear filter to an image. More...
 
static void sepFilter2D (Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY)
 Applies a separable linear filter to an image. More...
 
static void Sobel (Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
static void Sobel (Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
static void Sobel (Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
static void Sobel (Mat src, Mat dst, int ddepth, int dx, int dy, int ksize)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
static void Sobel (Mat src, Mat dst, int ddepth, int dx, int dy)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
static void spatialGradient (Mat src, Mat dx, Mat dy, int ksize, int borderType)
 Calculates the first order image derivative in both x and y using a Sobel operator. More...
 
static void spatialGradient (Mat src, Mat dx, Mat dy, int ksize)
 Calculates the first order image derivative in both x and y using a Sobel operator. More...
 
static void spatialGradient (Mat src, Mat dx, Mat dy)
 Calculates the first order image derivative in both x and y using a Sobel operator. More...
 
static void Scharr (Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta, int borderType)
 Calculates the first x- or y- image derivative using Scharr operator. More...
 
static void Scharr (Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta)
 Calculates the first x- or y- image derivative using Scharr operator. More...
 
static void Scharr (Mat src, Mat dst, int ddepth, int dx, int dy, double scale)
 Calculates the first x- or y- image derivative using Scharr operator. More...
 
static void Scharr (Mat src, Mat dst, int ddepth, int dx, int dy)
 Calculates the first x- or y- image derivative using Scharr operator. More...
 
static void Laplacian (Mat src, Mat dst, int ddepth, int ksize, double scale, double delta, int borderType)
 Calculates the Laplacian of an image. More...
 
static void Laplacian (Mat src, Mat dst, int ddepth, int ksize, double scale, double delta)
 Calculates the Laplacian of an image. More...
 
static void Laplacian (Mat src, Mat dst, int ddepth, int ksize, double scale)
 Calculates the Laplacian of an image. More...
 
static void Laplacian (Mat src, Mat dst, int ddepth, int ksize)
 Calculates the Laplacian of an image. More...
 
static void Laplacian (Mat src, Mat dst, int ddepth)
 Calculates the Laplacian of an image. More...
 
static void Canny (Mat image, Mat edges, double threshold1, double threshold2, int apertureSize, bool L2gradient)
 Finds edges in an image using the Canny algorithm [Canny86] . More...
 
static void Canny (Mat image, Mat edges, double threshold1, double threshold2, int apertureSize)
 Finds edges in an image using the Canny algorithm [Canny86] . More...
 
static void Canny (Mat image, Mat edges, double threshold1, double threshold2)
 Finds edges in an image using the Canny algorithm [Canny86] . More...
 
static void Canny (Mat dx, Mat dy, Mat edges, double threshold1, double threshold2, bool L2gradient)
 
static void Canny (Mat dx, Mat dy, Mat edges, double threshold1, double threshold2)
 
static void cornerMinEigenVal (Mat src, Mat dst, int blockSize, int ksize, int borderType)
 Calculates the minimal eigenvalue of gradient matrices for corner detection. More...
 
static void cornerMinEigenVal (Mat src, Mat dst, int blockSize, int ksize)
 Calculates the minimal eigenvalue of gradient matrices for corner detection. More...
 
static void cornerMinEigenVal (Mat src, Mat dst, int blockSize)
 Calculates the minimal eigenvalue of gradient matrices for corner detection. More...
 
static void cornerHarris (Mat src, Mat dst, int blockSize, int ksize, double k, int borderType)
 Harris corner detector. More...
 
static void cornerHarris (Mat src, Mat dst, int blockSize, int ksize, double k)
 Harris corner detector. More...
 
static void cornerEigenValsAndVecs (Mat src, Mat dst, int blockSize, int ksize, int borderType)
 Calculates eigenvalues and eigenvectors of image blocks for corner detection. More...
 
static void cornerEigenValsAndVecs (Mat src, Mat dst, int blockSize, int ksize)
 Calculates eigenvalues and eigenvectors of image blocks for corner detection. More...
 
static void preCornerDetect (Mat src, Mat dst, int ksize, int borderType)
 Calculates a feature map for corner detection. More...
 
static void preCornerDetect (Mat src, Mat dst, int ksize)
 Calculates a feature map for corner detection. More...
 
static void cornerSubPix (Mat image, Mat corners, Size winSize, Size zeroZone, TermCriteria criteria)
 Refines the corner locations. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, bool useHarrisDetector, double k)
 Determines strong corners on an image. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, bool useHarrisDetector)
 Determines strong corners on an image. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize)
 Determines strong corners on an image. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask)
 Determines strong corners on an image. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance)
 Determines strong corners on an image. More...
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, int gradientSize, bool useHarrisDetector, double k)
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, int gradientSize, bool useHarrisDetector)
 
static void goodFeaturesToTrack (Mat image, MatOfPoint corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, int gradientSize)
 
static void goodFeaturesToTrackWithQuality (Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality, int blockSize, int gradientSize, bool useHarrisDetector, double k)
 Same as above, but returns also quality measure of the detected corners. More...
 
static void goodFeaturesToTrackWithQuality (Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality, int blockSize, int gradientSize, bool useHarrisDetector)
 Same as above, but returns also quality measure of the detected corners. More...
 
static void goodFeaturesToTrackWithQuality (Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality, int blockSize, int gradientSize)
 Same as above, but returns also quality measure of the detected corners. More...
 
static void goodFeaturesToTrackWithQuality (Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality, int blockSize)
 Same as above, but returns also quality measure of the detected corners. More...
 
static void goodFeaturesToTrackWithQuality (Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality)
 Same as above, but returns also quality measure of the detected corners. More...
 
static void HoughLines (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)
 Finds lines in a binary image using the standard Hough transform. More...
 
static void HoughLines (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta)
 Finds lines in a binary image using the standard Hough transform. More...
 
static void HoughLines (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn)
 Finds lines in a binary image using the standard Hough transform. More...
 
static void HoughLines (Mat image, Mat lines, double rho, double theta, int threshold, double srn)
 Finds lines in a binary image using the standard Hough transform. More...
 
static void HoughLines (Mat image, Mat lines, double rho, double theta, int threshold)
 Finds lines in a binary image using the standard Hough transform. More...
 
static void HoughLinesP (Mat image, Mat lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap)
 Finds line segments in a binary image using the probabilistic Hough transform. More...
 
static void HoughLinesP (Mat image, Mat lines, double rho, double theta, int threshold, double minLineLength)
 Finds line segments in a binary image using the probabilistic Hough transform. More...
 
static void HoughLinesP (Mat image, Mat lines, double rho, double theta, int threshold)
 Finds line segments in a binary image using the probabilistic Hough transform. More...
 
static void HoughLinesPointSet (Mat point, Mat lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step)
 Finds lines in a set of points using the standard Hough transform. More...
 
static void HoughCircles (Mat image, Mat circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius)
 Finds circles in a grayscale image using the Hough transform. More...
 
static void HoughCircles (Mat image, Mat circles, int method, double dp, double minDist, double param1, double param2, int minRadius)
 Finds circles in a grayscale image using the Hough transform. More...
 
static void HoughCircles (Mat image, Mat circles, int method, double dp, double minDist, double param1, double param2)
 Finds circles in a grayscale image using the Hough transform. More...
 
static void HoughCircles (Mat image, Mat circles, int method, double dp, double minDist, double param1)
 Finds circles in a grayscale image using the Hough transform. More...
 
static void HoughCircles (Mat image, Mat circles, int method, double dp, double minDist)
 Finds circles in a grayscale image using the Hough transform. More...
 
static void erode (Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
 Erodes an image by using a specific structuring element. More...
 
static void erode (Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType)
 Erodes an image by using a specific structuring element. More...
 
static void erode (Mat src, Mat dst, Mat kernel, Point anchor, int iterations)
 Erodes an image by using a specific structuring element. More...
 
static void erode (Mat src, Mat dst, Mat kernel, Point anchor)
 Erodes an image by using a specific structuring element. More...
 
static void erode (Mat src, Mat dst, Mat kernel)
 Erodes an image by using a specific structuring element. More...
 
static void dilate (Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
 Dilates an image by using a specific structuring element. More...
 
static void dilate (Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType)
 Dilates an image by using a specific structuring element. More...
 
static void dilate (Mat src, Mat dst, Mat kernel, Point anchor, int iterations)
 Dilates an image by using a specific structuring element. More...
 
static void dilate (Mat src, Mat dst, Mat kernel, Point anchor)
 Dilates an image by using a specific structuring element. More...
 
static void dilate (Mat src, Mat dst, Mat kernel)
 Dilates an image by using a specific structuring element. More...
 
static void morphologyEx (Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)
 Performs advanced morphological transformations. More...
 
static void morphologyEx (Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations, int borderType)
 Performs advanced morphological transformations. More...
 
static void morphologyEx (Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations)
 Performs advanced morphological transformations. More...
 
static void morphologyEx (Mat src, Mat dst, int op, Mat kernel, Point anchor)
 Performs advanced morphological transformations. More...
 
static void morphologyEx (Mat src, Mat dst, int op, Mat kernel)
 Performs advanced morphological transformations. More...
 
static void resize (Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)
 Resizes an image. More...
 
static void resize (Mat src, Mat dst, Size dsize, double fx, double fy)
 Resizes an image. More...
 
static void resize (Mat src, Mat dst, Size dsize, double fx)
 Resizes an image. More...
 
static void resize (Mat src, Mat dst, Size dsize)
 Resizes an image. More...
 
static void warpAffine (Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)
 Applies an affine transformation to an image. More...
 
static void warpAffine (Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode)
 Applies an affine transformation to an image. More...
 
static void warpAffine (Mat src, Mat dst, Mat M, Size dsize, int flags)
 Applies an affine transformation to an image. More...
 
static void warpAffine (Mat src, Mat dst, Mat M, Size dsize)
 Applies an affine transformation to an image. More...
 
static void warpPerspective (Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)
 Applies a perspective transformation to an image. More...
 
static void warpPerspective (Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode)
 Applies a perspective transformation to an image. More...
 
static void warpPerspective (Mat src, Mat dst, Mat M, Size dsize, int flags)
 Applies a perspective transformation to an image. More...
 
static void warpPerspective (Mat src, Mat dst, Mat M, Size dsize)
 Applies a perspective transformation to an image. More...
 
static void remap (Mat src, Mat dst, Mat map1, Mat map2, int interpolation, int borderMode, Scalar borderValue)
 Applies a generic geometrical transformation to an image. More...
 
static void remap (Mat src, Mat dst, Mat map1, Mat map2, int interpolation, int borderMode)
 Applies a generic geometrical transformation to an image. More...
 
static void remap (Mat src, Mat dst, Mat map1, Mat map2, int interpolation)
 Applies a generic geometrical transformation to an image. More...
 
static void convertMaps (Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type, bool nninterpolation)
 Converts image transformation maps from one representation to another. More...
 
static void convertMaps (Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type)
 Converts image transformation maps from one representation to another. More...
 
static Mat getRotationMatrix2D (Point center, double angle, double scale)
 Calculates an affine matrix of 2D rotation. More...
 
static void invertAffineTransform (Mat M, Mat iM)
 Inverts an affine transformation. More...
 
static Mat getPerspectiveTransform (Mat src, Mat dst, int solveMethod)
 Calculates a perspective transform from four pairs of the corresponding points. More...
 
static Mat getPerspectiveTransform (Mat src, Mat dst)
 Calculates a perspective transform from four pairs of the corresponding points. More...
 
static Mat getAffineTransform (MatOfPoint2f src, MatOfPoint2f dst)
 
static void getRectSubPix (Mat image, Size patchSize, Point center, Mat patch, int patchType)
 Retrieves a pixel rectangle from an image with sub-pixel accuracy. More...
 
static void getRectSubPix (Mat image, Size patchSize, Point center, Mat patch)
 Retrieves a pixel rectangle from an image with sub-pixel accuracy. More...
 
static void logPolar (Mat src, Mat dst, Point center, double M, int flags)
 Remaps an image to semilog-polar coordinates space. More...
 
static void linearPolar (Mat src, Mat dst, Point center, double maxRadius, int flags)
 Remaps an image to polar coordinates space. More...
 
static void warpPolar (Mat src, Mat dst, Size dsize, Point center, double maxRadius, int flags)
 Remaps an image to polar or semilog-polar coordinates space. More...
 
static void integral3 (Mat src, Mat sum, Mat sqsum, Mat tilted, int sdepth, int sqdepth)
 Calculates the integral of an image. More...
 
static void integral3 (Mat src, Mat sum, Mat sqsum, Mat tilted, int sdepth)
 Calculates the integral of an image. More...
 
static void integral3 (Mat src, Mat sum, Mat sqsum, Mat tilted)
 Calculates the integral of an image. More...
 
static void integral (Mat src, Mat sum, int sdepth)
 
static void integral (Mat src, Mat sum)
 
static void integral2 (Mat src, Mat sum, Mat sqsum, int sdepth, int sqdepth)
 
static void integral2 (Mat src, Mat sum, Mat sqsum, int sdepth)
 
static void integral2 (Mat src, Mat sum, Mat sqsum)
 
static void accumulate (Mat src, Mat dst, Mat mask)
 Adds an image to the accumulator image. More...
 
static void accumulate (Mat src, Mat dst)
 Adds an image to the accumulator image. More...
 
static void accumulateSquare (Mat src, Mat dst, Mat mask)
 Adds the square of a source image to the accumulator image. More...
 
static void accumulateSquare (Mat src, Mat dst)
 Adds the square of a source image to the accumulator image. More...
 
static void accumulateProduct (Mat src1, Mat src2, Mat dst, Mat mask)
 Adds the per-element product of two input images to the accumulator image. More...
 
static void accumulateProduct (Mat src1, Mat src2, Mat dst)
 Adds the per-element product of two input images to the accumulator image. More...
 
static void accumulateWeighted (Mat src, Mat dst, double alpha, Mat mask)
 Updates a running average. More...
 
static void accumulateWeighted (Mat src, Mat dst, double alpha)
 Updates a running average. More...
 
static Point phaseCorrelate (Mat src1, Mat src2, Mat window, double[] response)
 The function is used to detect translational shifts that occur between two images. More...
 
static Point phaseCorrelate (Mat src1, Mat src2, Mat window)
 The function is used to detect translational shifts that occur between two images. More...
 
static Point phaseCorrelate (Mat src1, Mat src2)
 The function is used to detect translational shifts that occur between two images. More...
 
static void createHanningWindow (Mat dst, Size winSize, int type)
 This function computes a Hanning window coefficients in two dimensions. More...
 
static void divSpectrums (Mat a, Mat b, Mat c, int flags, bool conjB)
 Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum. More...
 
static void divSpectrums (Mat a, Mat b, Mat c, int flags)
 Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum. More...
 
static double threshold (Mat src, Mat dst, double thresh, double maxval, int type)
 Applies a fixed-level threshold to each array element. More...
 
static void adaptiveThreshold (Mat src, Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
 Applies an adaptive threshold to an array. More...
 
static void pyrDown (Mat src, Mat dst, Size dstsize, int borderType)
 Blurs an image and downsamples it. More...
 
static void pyrDown (Mat src, Mat dst, Size dstsize)
 Blurs an image and downsamples it. More...
 
static void pyrDown (Mat src, Mat dst)
 Blurs an image and downsamples it. More...
 
static void pyrUp (Mat src, Mat dst, Size dstsize, int borderType)
 Upsamples an image and then blurs it. More...
 
static void pyrUp (Mat src, Mat dst, Size dstsize)
 Upsamples an image and then blurs it. More...
 
static void pyrUp (Mat src, Mat dst)
 Upsamples an image and then blurs it. More...
 
static void calcHist (List< Mat > images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges, bool accumulate)
 
static void calcHist (List< Mat > images, MatOfInt channels, Mat mask, Mat hist, MatOfInt histSize, MatOfFloat ranges)
 
static void calcBackProject (List< Mat > images, MatOfInt channels, Mat hist, Mat dst, MatOfFloat ranges, double scale)
 
static double compareHist (Mat H1, Mat H2, int method)
 Compares two histograms. More...
 
static void equalizeHist (Mat src, Mat dst)
 Equalizes the histogram of a grayscale image. More...
 
static CLAHE createCLAHE (double clipLimit, Size tileGridSize)
 Creates a smart pointer to a cv::CLAHE class and initializes it. More...
 
static CLAHE createCLAHE (double clipLimit)
 Creates a smart pointer to a cv::CLAHE class and initializes it. More...
 
static CLAHE createCLAHE ()
 Creates a smart pointer to a cv::CLAHE class and initializes it. More...
 
static float EMD (Mat signature1, Mat signature2, int distType, Mat cost, Mat flow)
 Computes the "minimal work" distance between two weighted point configurations. More...
 
static float EMD (Mat signature1, Mat signature2, int distType, Mat cost)
 Computes the "minimal work" distance between two weighted point configurations. More...
 
static float EMD (Mat signature1, Mat signature2, int distType)
 Computes the "minimal work" distance between two weighted point configurations. More...
 
static void watershed (Mat image, Mat markers)
 Performs a marker-based image segmentation using the watershed algorithm. More...
 
static void pyrMeanShiftFiltering (Mat src, Mat dst, double sp, double sr, int maxLevel, TermCriteria termcrit)
 Performs initial step of meanshift segmentation of an image. More...
 
static void pyrMeanShiftFiltering (Mat src, Mat dst, double sp, double sr, int maxLevel)
 Performs initial step of meanshift segmentation of an image. More...
 
static void pyrMeanShiftFiltering (Mat src, Mat dst, double sp, double sr)
 Performs initial step of meanshift segmentation of an image. More...
 
static void grabCut (Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount, int mode)
 Runs the GrabCut algorithm. More...
 
static void grabCut (Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount)
 Runs the GrabCut algorithm. More...
 
static void distanceTransformWithLabels (Mat src, Mat dst, Mat labels, int distanceType, int maskSize, int labelType)
 Calculates the distance to the closest zero pixel for each pixel of the source image. More...
 
static void distanceTransformWithLabels (Mat src, Mat dst, Mat labels, int distanceType, int maskSize)
 Calculates the distance to the closest zero pixel for each pixel of the source image. More...
 
static void distanceTransform (Mat src, Mat dst, int distanceType, int maskSize, int dstType)
 
static void distanceTransform (Mat src, Mat dst, int distanceType, int maskSize)
 
static int floodFill (Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff, int flags)
 Fills a connected component with the given color. More...
 
static int floodFill (Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff)
 Fills a connected component with the given color. More...
 
static int floodFill (Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff)
 Fills a connected component with the given color. More...
 
static int floodFill (Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect)
 Fills a connected component with the given color. More...
 
static int floodFill (Mat image, Mat mask, Point seedPoint, Scalar newVal)
 Fills a connected component with the given color. More...
 
static void blendLinear (Mat src1, Mat src2, Mat weights1, Mat weights2, Mat dst)
 
static void cvtColor (Mat src, Mat dst, int code, int dstCn)
 Converts an image from one color space to another. More...
 
static void cvtColor (Mat src, Mat dst, int code)
 Converts an image from one color space to another. More...
 
static void cvtColorTwoPlane (Mat src1, Mat src2, Mat dst, int code)
 Converts an image from one color space to another where the source image is stored in two planes. More...
 
static void demosaicing (Mat src, Mat dst, int code, int dstCn)
 main function for all demosaicing processes More...
 
static void demosaicing (Mat src, Mat dst, int code)
 main function for all demosaicing processes More...
 
static Moments moments (Mat array, bool binaryImage)
 Calculates all of the moments up to the third order of a polygon or rasterized shape. More...
 
static Moments moments (Mat array)
 Calculates all of the moments up to the third order of a polygon or rasterized shape. More...
 
static void HuMoments (Moments m, Mat hu)
 
static void matchTemplate (Mat image, Mat templ, Mat result, int method, Mat mask)
 Compares a template against overlapped image regions. More...
 
static void matchTemplate (Mat image, Mat templ, Mat result, int method)
 Compares a template against overlapped image regions. More...
 
static int connectedComponentsWithAlgorithm (Mat image, Mat labels, int connectivity, int ltype, int ccltype)
 computes the connected components labeled image of boolean image More...
 
static int connectedComponents (Mat image, Mat labels, int connectivity, int ltype)
 
static int connectedComponents (Mat image, Mat labels, int connectivity)
 
static int connectedComponents (Mat image, Mat labels)
 
static int connectedComponentsWithStatsWithAlgorithm (Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype, int ccltype)
 computes the connected components labeled image of boolean image and also produces a statistics output for each label More...
 
static int connectedComponentsWithStats (Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype)
 
static int connectedComponentsWithStats (Mat image, Mat labels, Mat stats, Mat centroids, int connectivity)
 
static int connectedComponentsWithStats (Mat image, Mat labels, Mat stats, Mat centroids)
 
static void findContours (Mat image, List< MatOfPoint > contours, Mat hierarchy, int mode, int method, Point offset)
 Finds contours in a binary image. More...
 
static void findContours (Mat image, List< MatOfPoint > contours, Mat hierarchy, int mode, int method)
 Finds contours in a binary image. More...
 
static void approxPolyDP (MatOfPoint2f curve, MatOfPoint2f approxCurve, double epsilon, bool closed)
 Approximates a polygonal curve(s) with the specified precision. More...
 
static double arcLength (MatOfPoint2f curve, bool closed)
 Calculates a contour perimeter or a curve length. More...
 
static Rect boundingRect (Mat array)
 Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image. More...
 
static double contourArea (Mat contour, bool oriented)
 Calculates a contour area. More...
 
static double contourArea (Mat contour)
 Calculates a contour area. More...
 
static RotatedRect minAreaRect (MatOfPoint2f points)
 Finds a rotated rectangle of the minimum area enclosing the input 2D point set. More...
 
static void boxPoints (RotatedRect box, Mat points)
 Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle. More...
 
static void minEnclosingCircle (MatOfPoint2f points, Point center, float[] radius)
 Finds a circle of the minimum area enclosing a 2D point set. More...
 
static double minEnclosingTriangle (Mat points, Mat triangle)
 Finds a triangle of minimum area enclosing a 2D point set and returns its area. More...
 
static double matchShapes (Mat contour1, Mat contour2, int method, double parameter)
 Compares two shapes. More...
 
static void convexHull (MatOfPoint points, MatOfInt hull, bool clockwise)
 Finds the convex hull of a point set. More...
 
static void convexHull (MatOfPoint points, MatOfInt hull)
 Finds the convex hull of a point set. More...
 
static void convexityDefects (MatOfPoint contour, MatOfInt convexhull, MatOfInt4 convexityDefects)
 Finds the convexity defects of a contour. More...
 
static bool isContourConvex (MatOfPoint contour)
 Tests a contour convexity. More...
 
static float intersectConvexConvex (Mat p1, Mat p2, Mat p12, bool handleNested)
 Finds intersection of two convex polygons. More...
 
static float intersectConvexConvex (Mat p1, Mat p2, Mat p12)
 Finds intersection of two convex polygons. More...
 
static RotatedRect fitEllipse (MatOfPoint2f points)
 Fits an ellipse around a set of 2D points. More...
 
static RotatedRect fitEllipseAMS (Mat points)
 Fits an ellipse around a set of 2D points. More...
 
static RotatedRect fitEllipseDirect (Mat points)
 Fits an ellipse around a set of 2D points. More...
 
static void fitLine (Mat points, Mat line, int distType, double param, double reps, double aeps)
 Fits a line to a 2D or 3D point set. More...
 
static double pointPolygonTest (MatOfPoint2f contour, Point pt, bool measureDist)
 Performs a point-in-contour test. More...
 
static int rotatedRectangleIntersection (RotatedRect rect1, RotatedRect rect2, Mat intersectingRegion)
 Finds out if there is any intersection between two rotated rectangles. More...
 
static GeneralizedHoughBallard createGeneralizedHoughBallard ()
 Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it. More...
 
static GeneralizedHoughGuil createGeneralizedHoughGuil ()
 Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it. More...
 
static void applyColorMap (Mat src, Mat dst, int colormap)
 Applies a GNU Octave/MATLAB equivalent colormap on a given image. More...
 
static void applyColorMap (Mat src, Mat dst, Mat userColor)
 Applies a user colormap on a given image. More...
 
static void line (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)
 Draws a line segment connecting two points. More...
 
static void line (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType)
 Draws a line segment connecting two points. More...
 
static void line (Mat img, Point pt1, Point pt2, Scalar color, int thickness)
 Draws a line segment connecting two points. More...
 
static void line (Mat img, Point pt1, Point pt2, Scalar color)
 Draws a line segment connecting two points. More...
 
static void arrowedLine (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type, int shift, double tipLength)
 Draws an arrow segment pointing from the first point to the second one. More...
 
static void arrowedLine (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type, int shift)
 Draws an arrow segment pointing from the first point to the second one. More...
 
static void arrowedLine (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type)
 Draws an arrow segment pointing from the first point to the second one. More...
 
static void arrowedLine (Mat img, Point pt1, Point pt2, Scalar color, int thickness)
 Draws an arrow segment pointing from the first point to the second one. More...
 
static void arrowedLine (Mat img, Point pt1, Point pt2, Scalar color)
 Draws an arrow segment pointing from the first point to the second one. More...
 
static void rectangle (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)
 Draws a simple, thick, or filled up-right rectangle. More...
 
static void rectangle (Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType)
 Draws a simple, thick, or filled up-right rectangle. More...
 
static void rectangle (Mat img, Point pt1, Point pt2, Scalar color, int thickness)
 Draws a simple, thick, or filled up-right rectangle. More...
 
static void rectangle (Mat img, Point pt1, Point pt2, Scalar color)
 Draws a simple, thick, or filled up-right rectangle. More...
 
static void rectangle (Mat img, Rect rec, Scalar color, int thickness, int lineType, int shift)
 
static void rectangle (Mat img, Rect rec, Scalar color, int thickness, int lineType)
 
static void rectangle (Mat img, Rect rec, Scalar color, int thickness)
 
static void rectangle (Mat img, Rect rec, Scalar color)
 
static void circle (Mat img, Point center, int radius, Scalar color, int thickness, int lineType, int shift)
 Draws a circle. More...
 
static void circle (Mat img, Point center, int radius, Scalar color, int thickness, int lineType)
 Draws a circle. More...
 
static void circle (Mat img, Point center, int radius, Scalar color, int thickness)
 Draws a circle. More...
 
static void circle (Mat img, Point center, int radius, Scalar color)
 Draws a circle. More...
 
static void ellipse (Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness, int lineType, int shift)
 Draws a simple or thick elliptic arc or fills an ellipse sector. More...
 
static void ellipse (Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness, int lineType)
 Draws a simple or thick elliptic arc or fills an ellipse sector. More...
 
static void ellipse (Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness)
 Draws a simple or thick elliptic arc or fills an ellipse sector. More...
 
static void ellipse (Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color)
 Draws a simple or thick elliptic arc or fills an ellipse sector. More...
 
static void ellipse (Mat img, RotatedRect box, Scalar color, int thickness, int lineType)
 
static void ellipse (Mat img, RotatedRect box, Scalar color, int thickness)
 
static void ellipse (Mat img, RotatedRect box, Scalar color)
 
static void drawMarker (Mat img, Point position, Scalar color, int markerType, int markerSize, int thickness, int line_type)
 Draws a marker on a predefined position in an image. More...
 
static void drawMarker (Mat img, Point position, Scalar color, int markerType, int markerSize, int thickness)
 Draws a marker on a predefined position in an image. More...
 
static void drawMarker (Mat img, Point position, Scalar color, int markerType, int markerSize)
 Draws a marker on a predefined position in an image. More...
 
static void drawMarker (Mat img, Point position, Scalar color, int markerType)
 Draws a marker on a predefined position in an image. More...
 
static void drawMarker (Mat img, Point position, Scalar color)
 Draws a marker on a predefined position in an image. More...
 
static void fillConvexPoly (Mat img, MatOfPoint points, Scalar color, int lineType, int shift)
 Fills a convex polygon. More...
 
static void fillConvexPoly (Mat img, MatOfPoint points, Scalar color, int lineType)
 Fills a convex polygon. More...
 
static void fillConvexPoly (Mat img, MatOfPoint points, Scalar color)
 Fills a convex polygon. More...
 
static void fillPoly (Mat img, List< MatOfPoint > pts, Scalar color, int lineType, int shift, Point offset)
 Fills the area bounded by one or more polygons. More...
 
static void fillPoly (Mat img, List< MatOfPoint > pts, Scalar color, int lineType, int shift)
 Fills the area bounded by one or more polygons. More...
 
static void fillPoly (Mat img, List< MatOfPoint > pts, Scalar color, int lineType)
 Fills the area bounded by one or more polygons. More...
 
static void fillPoly (Mat img, List< MatOfPoint > pts, Scalar color)
 Fills the area bounded by one or more polygons. More...
 
static void polylines (Mat img, List< MatOfPoint > pts, bool isClosed, Scalar color, int thickness, int lineType, int shift)
 Draws several polygonal curves. More...
 
static void polylines (Mat img, List< MatOfPoint > pts, bool isClosed, Scalar color, int thickness, int lineType)
 Draws several polygonal curves. More...
 
static void polylines (Mat img, List< MatOfPoint > pts, bool isClosed, Scalar color, int thickness)
 Draws several polygonal curves. More...
 
static void polylines (Mat img, List< MatOfPoint > pts, bool isClosed, Scalar color)
 Draws several polygonal curves. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset)
 Draws contours outlines or filled contours. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel)
 Draws contours outlines or filled contours. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy)
 Draws contours outlines or filled contours. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color, int thickness, int lineType)
 Draws contours outlines or filled contours. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color, int thickness)
 Draws contours outlines or filled contours. More...
 
static void drawContours (Mat image, List< MatOfPoint > contours, int contourIdx, Scalar color)
 Draws contours outlines or filled contours. More...
 
static bool clipLine (Rect imgRect, Point pt1, Point pt2)
 
static void ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, MatOfPoint pts)
 Approximates an elliptic arc with a polyline. More...
 
static void putText (Mat img, string text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, bool bottomLeftOrigin)
 Draws a text string. More...
 
static void putText (Mat img, string text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType)
 Draws a text string. More...
 
static void putText (Mat img, string text, Point org, int fontFace, double fontScale, Scalar color, int thickness)
 Draws a text string. More...
 
static void putText (Mat img, string text, Point org, int fontFace, double fontScale, Scalar color)
 Draws a text string. More...
 
static double getFontScaleFromHeight (int fontFace, int pixelHeight, int thickness)
 Calculates the font-specific size to use to achieve a given height in pixels. More...
 
static double getFontScaleFromHeight (int fontFace, int pixelHeight)
 Calculates the font-specific size to use to achieve a given height in pixels. More...
 
static void HoughLinesWithAccumulator (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)
 Finds lines in a binary image using the standard Hough transform and get accumulator. More...
 
static void HoughLinesWithAccumulator (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta)
 Finds lines in a binary image using the standard Hough transform and get accumulator. More...
 
static void HoughLinesWithAccumulator (Mat image, Mat lines, double rho, double theta, int threshold, double srn, double stn)
 Finds lines in a binary image using the standard Hough transform and get accumulator. More...
 
static void HoughLinesWithAccumulator (Mat image, Mat lines, double rho, double theta, int threshold, double srn)
 Finds lines in a binary image using the standard Hough transform and get accumulator. More...
 
static void HoughLinesWithAccumulator (Mat image, Mat lines, double rho, double theta, int threshold)
 Finds lines in a binary image using the standard Hough transform and get accumulator. More...
 
static Size getTextSize (string text, int fontFace, double fontScale, int thickness, int[] baseLine)
 

Public Attributes

const int CV_GAUSSIAN_5x5 = 7
 
const int CV_SCHARR = -1
 
const int CV_MAX_SOBEL_KSIZE = 7
 
const int CV_RGBA2mRGBA = 125
 
const int CV_mRGBA2RGBA = 126
 
const int CV_WARP_FILL_OUTLIERS = 8
 
const int CV_WARP_INVERSE_MAP = 16
 
const int CV_CHAIN_CODE = 0
 
const int CV_LINK_RUNS = 5
 
const int CV_POLY_APPROX_DP = 0
 
const int CV_CONTOURS_MATCH_I1 = 1
 
const int CV_CONTOURS_MATCH_I2 = 2
 
const int CV_CONTOURS_MATCH_I3 = 3
 
const int CV_CLOCKWISE = 1
 
const int CV_COUNTER_CLOCKWISE = 2
 
const int CV_COMP_CORREL = 0
 
const int CV_COMP_CHISQR = 1
 
const int CV_COMP_INTERSECT = 2
 
const int CV_COMP_BHATTACHARYYA = 3
 
const int CV_COMP_HELLINGER = CV_COMP_BHATTACHARYYA
 
const int CV_COMP_CHISQR_ALT = 4
 
const int CV_COMP_KL_DIV = 5
 
const int CV_DIST_MASK_3 = 3
 
const int CV_DIST_MASK_5 = 5
 
const int CV_DIST_MASK_PRECISE = 0
 
const int CV_DIST_LABEL_CCOMP = 0
 
const int CV_DIST_LABEL_PIXEL = 1
 
const int CV_DIST_USER = -1
 
const int CV_DIST_L1 = 1
 
const int CV_DIST_L2 = 2
 
const int CV_DIST_C = 3
 
const int CV_DIST_L12 = 4
 
const int CV_DIST_FAIR = 5
 
const int CV_DIST_WELSCH = 6
 
const int CV_DIST_HUBER = 7
 
const int CV_CANNY_L2_GRADIENT = (1 << 31)
 
const int CV_HOUGH_STANDARD = 0
 
const int CV_HOUGH_PROBABILISTIC = 1
 
const int CV_HOUGH_MULTI_SCALE = 2
 
const int CV_HOUGH_GRADIENT = 3
 
const int CV_SHAPE_RECT = 0
 
const int CV_SHAPE_CROSS = 1
 
const int CV_SHAPE_ELLIPSE = 2
 
const int CV_SHAPE_CUSTOM = 100
 
const int CV_BLUR_NO_SCALE = 0
 
const int CV_BLUR = 1
 
const int CV_GAUSSIAN = 2
 
const int CV_MEDIAN = 3
 
const int CV_BILATERAL = 4
 
const int ADAPTIVE_THRESH_MEAN_C = 0
 
const int ADAPTIVE_THRESH_GAUSSIAN_C = 1
 
const int COLOR_BGR2BGRA = 0
 
const int COLOR_RGB2RGBA = COLOR_BGR2BGRA
 
const int COLOR_BGRA2BGR = 1
 
const int COLOR_RGBA2RGB = COLOR_BGRA2BGR
 
const int COLOR_BGR2RGBA = 2
 
const int COLOR_RGB2BGRA = COLOR_BGR2RGBA
 
const int COLOR_RGBA2BGR = 3
 
const int COLOR_BGRA2RGB = COLOR_RGBA2BGR
 
const int COLOR_BGR2RGB = 4
 
const int COLOR_RGB2BGR = COLOR_BGR2RGB
 
const int COLOR_BGRA2RGBA = 5
 
const int COLOR_RGBA2BGRA = COLOR_BGRA2RGBA
 
const int COLOR_BGR2GRAY = 6
 
const int COLOR_RGB2GRAY = 7
 
const int COLOR_GRAY2BGR = 8
 
const int COLOR_GRAY2RGB = COLOR_GRAY2BGR
 
const int COLOR_GRAY2BGRA = 9
 
const int COLOR_GRAY2RGBA = COLOR_GRAY2BGRA
 
const int COLOR_BGRA2GRAY = 10
 
const int COLOR_RGBA2GRAY = 11
 
const int COLOR_BGR2BGR565 = 12
 
const int COLOR_RGB2BGR565 = 13
 
const int COLOR_BGR5652BGR = 14
 
const int COLOR_BGR5652RGB = 15
 
const int COLOR_BGRA2BGR565 = 16
 
const int COLOR_RGBA2BGR565 = 17
 
const int COLOR_BGR5652BGRA = 18
 
const int COLOR_BGR5652RGBA = 19
 
const int COLOR_GRAY2BGR565 = 20
 
const int COLOR_BGR5652GRAY = 21
 
const int COLOR_BGR2BGR555 = 22
 
const int COLOR_RGB2BGR555 = 23
 
const int COLOR_BGR5552BGR = 24
 
const int COLOR_BGR5552RGB = 25
 
const int COLOR_BGRA2BGR555 = 26
 
const int COLOR_RGBA2BGR555 = 27
 
const int COLOR_BGR5552BGRA = 28
 
const int COLOR_BGR5552RGBA = 29
 
const int COLOR_GRAY2BGR555 = 30
 
const int COLOR_BGR5552GRAY = 31
 
const int COLOR_BGR2XYZ = 32
 
const int COLOR_RGB2XYZ = 33
 
const int COLOR_XYZ2BGR = 34
 
const int COLOR_XYZ2RGB = 35
 
const int COLOR_BGR2YCrCb = 36
 
const int COLOR_RGB2YCrCb = 37
 
const int COLOR_YCrCb2BGR = 38
 
const int COLOR_YCrCb2RGB = 39
 
const int COLOR_BGR2HSV = 40
 
const int COLOR_RGB2HSV = 41
 
const int COLOR_BGR2Lab = 44
 
const int COLOR_RGB2Lab = 45
 
const int COLOR_BGR2Luv = 50
 
const int COLOR_RGB2Luv = 51
 
const int COLOR_BGR2HLS = 52
 
const int COLOR_RGB2HLS = 53
 
const int COLOR_HSV2BGR = 54
 
const int COLOR_HSV2RGB = 55
 
const int COLOR_Lab2BGR = 56
 
const int COLOR_Lab2RGB = 57
 
const int COLOR_Luv2BGR = 58
 
const int COLOR_Luv2RGB = 59
 
const int COLOR_HLS2BGR = 60
 
const int COLOR_HLS2RGB = 61
 
const int COLOR_BGR2HSV_FULL = 66
 
const int COLOR_RGB2HSV_FULL = 67
 
const int COLOR_BGR2HLS_FULL = 68
 
const int COLOR_RGB2HLS_FULL = 69
 
const int COLOR_HSV2BGR_FULL = 70
 
const int COLOR_HSV2RGB_FULL = 71
 
const int COLOR_HLS2BGR_FULL = 72
 
const int COLOR_HLS2RGB_FULL = 73
 
const int COLOR_LBGR2Lab = 74
 
const int COLOR_LRGB2Lab = 75
 
const int COLOR_LBGR2Luv = 76
 
const int COLOR_LRGB2Luv = 77
 
const int COLOR_Lab2LBGR = 78
 
const int COLOR_Lab2LRGB = 79
 
const int COLOR_Luv2LBGR = 80
 
const int COLOR_Luv2LRGB = 81
 
const int COLOR_BGR2YUV = 82
 
const int COLOR_RGB2YUV = 83
 
const int COLOR_YUV2BGR = 84
 
const int COLOR_YUV2RGB = 85
 
const int COLOR_YUV2RGB_NV12 = 90
 
const int COLOR_YUV2BGR_NV12 = 91
 
const int COLOR_YUV2RGB_NV21 = 92
 
const int COLOR_YUV2BGR_NV21 = 93
 
const int COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21
 
const int COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21
 
const int COLOR_YUV2RGBA_NV12 = 94
 
const int COLOR_YUV2BGRA_NV12 = 95
 
const int COLOR_YUV2RGBA_NV21 = 96
 
const int COLOR_YUV2BGRA_NV21 = 97
 
const int COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21
 
const int COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21
 
const int COLOR_YUV2RGB_YV12 = 98
 
const int COLOR_YUV2BGR_YV12 = 99
 
const int COLOR_YUV2RGB_IYUV = 100
 
const int COLOR_YUV2BGR_IYUV = 101
 
const int COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV
 
const int COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV
 
const int COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12
 
const int COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12
 
const int COLOR_YUV2RGBA_YV12 = 102
 
const int COLOR_YUV2BGRA_YV12 = 103
 
const int COLOR_YUV2RGBA_IYUV = 104
 
const int COLOR_YUV2BGRA_IYUV = 105
 
const int COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV
 
const int COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV
 
const int COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12
 
const int COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12
 
const int COLOR_YUV2GRAY_420 = 106
 
const int COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420
 
const int COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420
 
const int COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420
 
const int COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420
 
const int COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420
 
const int COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420
 
const int COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420
 
const int COLOR_YUV2RGB_UYVY = 107
 
const int COLOR_YUV2BGR_UYVY = 108
 
const int COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY
 
const int COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY
 
const int COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY
 
const int COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY
 
const int COLOR_YUV2RGBA_UYVY = 111
 
const int COLOR_YUV2BGRA_UYVY = 112
 
const int COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY
 
const int COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY
 
const int COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY
 
const int COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY
 
const int COLOR_YUV2RGB_YUY2 = 115
 
const int COLOR_YUV2BGR_YUY2 = 116
 
const int COLOR_YUV2RGB_YVYU = 117
 
const int COLOR_YUV2BGR_YVYU = 118
 
const int COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2
 
const int COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2
 
const int COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2
 
const int COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2
 
const int COLOR_YUV2RGBA_YUY2 = 119
 
const int COLOR_YUV2BGRA_YUY2 = 120
 
const int COLOR_YUV2RGBA_YVYU = 121
 
const int COLOR_YUV2BGRA_YVYU = 122
 
const int COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2
 
const int COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2
 
const int COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2
 
const int COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2
 
const int COLOR_YUV2GRAY_UYVY = 123
 
const int COLOR_YUV2GRAY_YUY2 = 124
 
const int COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY
 
const int COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY
 
const int COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2
 
const int COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2
 
const int COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2
 
const int COLOR_RGBA2mRGBA = 125
 
const int COLOR_mRGBA2RGBA = 126
 
const int COLOR_RGB2YUV_I420 = 127
 
const int COLOR_BGR2YUV_I420 = 128
 
const int COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420
 
const int COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420
 
const int COLOR_RGBA2YUV_I420 = 129
 
const int COLOR_BGRA2YUV_I420 = 130
 
const int COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420
 
const int COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420
 
const int COLOR_RGB2YUV_YV12 = 131
 
const int COLOR_BGR2YUV_YV12 = 132
 
const int COLOR_RGBA2YUV_YV12 = 133
 
const int COLOR_BGRA2YUV_YV12 = 134
 
const int COLOR_BayerBG2BGR = 46
 
const int COLOR_BayerGB2BGR = 47
 
const int COLOR_BayerRG2BGR = 48
 
const int COLOR_BayerGR2BGR = 49
 
const int COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR
 
const int COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR
 
const int COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR
 
const int COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR
 
const int COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR
 
const int COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR
 
const int COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR
 
const int COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR
 
const int COLOR_BayerBG2RGB = COLOR_BayerRG2BGR
 
const int COLOR_BayerGB2RGB = COLOR_BayerGR2BGR
 
const int COLOR_BayerRG2RGB = COLOR_BayerBG2BGR
 
const int COLOR_BayerGR2RGB = COLOR_BayerGB2BGR
 
const int COLOR_BayerBG2GRAY = 86
 
const int COLOR_BayerGB2GRAY = 87
 
const int COLOR_BayerRG2GRAY = 88
 
const int COLOR_BayerGR2GRAY = 89
 
const int COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY
 
const int COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY
 
const int COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY
 
const int COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY
 
const int COLOR_BayerBG2BGR_VNG = 62
 
const int COLOR_BayerGB2BGR_VNG = 63
 
const int COLOR_BayerRG2BGR_VNG = 64
 
const int COLOR_BayerGR2BGR_VNG = 65
 
const int COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG
 
const int COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG
 
const int COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG
 
const int COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG
 
const int COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG
 
const int COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG
 
const int COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG
 
const int COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG
 
const int COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG
 
const int COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG
 
const int COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG
 
const int COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG
 
const int COLOR_BayerBG2BGR_EA = 135
 
const int COLOR_BayerGB2BGR_EA = 136
 
const int COLOR_BayerRG2BGR_EA = 137
 
const int COLOR_BayerGR2BGR_EA = 138
 
const int COLOR_BayerRGGB2BGR_EA = COLOR_BayerBG2BGR_EA
 
const int COLOR_BayerGRBG2BGR_EA = COLOR_BayerGB2BGR_EA
 
const int COLOR_BayerBGGR2BGR_EA = COLOR_BayerRG2BGR_EA
 
const int COLOR_BayerGBRG2BGR_EA = COLOR_BayerGR2BGR_EA
 
const int COLOR_BayerRGGB2RGB_EA = COLOR_BayerBGGR2BGR_EA
 
const int COLOR_BayerGRBG2RGB_EA = COLOR_BayerGBRG2BGR_EA
 
const int COLOR_BayerBGGR2RGB_EA = COLOR_BayerRGGB2BGR_EA
 
const int COLOR_BayerGBRG2RGB_EA = COLOR_BayerGRBG2BGR_EA
 
const int COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA
 
const int COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA
 
const int COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA
 
const int COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA
 
const int COLOR_BayerBG2BGRA = 139
 
const int COLOR_BayerGB2BGRA = 140
 
const int COLOR_BayerRG2BGRA = 141
 
const int COLOR_BayerGR2BGRA = 142
 
const int COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA
 
const int COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA
 
const int COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA
 
const int COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA
 
const int COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA
 
const int COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA
 
const int COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA
 
const int COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA
 
const int COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA
 
const int COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA
 
const int COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA
 
const int COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA
 
const int COLOR_RGB2YUV_UYVY = 143
 
const int COLOR_BGR2YUV_UYVY = 144
 
const int COLOR_RGB2YUV_Y422 = COLOR_RGB2YUV_UYVY
 
const int COLOR_BGR2YUV_Y422 = COLOR_BGR2YUV_UYVY
 
const int COLOR_RGB2YUV_UYNV = COLOR_RGB2YUV_UYVY
 
const int COLOR_BGR2YUV_UYNV = COLOR_BGR2YUV_UYVY
 
const int COLOR_RGBA2YUV_UYVY = 145
 
const int COLOR_BGRA2YUV_UYVY = 146
 
const int COLOR_RGBA2YUV_Y422 = COLOR_RGBA2YUV_UYVY
 
const int COLOR_BGRA2YUV_Y422 = COLOR_BGRA2YUV_UYVY
 
const int COLOR_RGBA2YUV_UYNV = COLOR_RGBA2YUV_UYVY
 
const int COLOR_BGRA2YUV_UYNV = COLOR_BGRA2YUV_UYVY
 
const int COLOR_RGB2YUV_YUY2 = 147
 
const int COLOR_BGR2YUV_YUY2 = 148
 
const int COLOR_RGB2YUV_YVYU = 149
 
const int COLOR_BGR2YUV_YVYU = 150
 
const int COLOR_RGB2YUV_YUYV = COLOR_RGB2YUV_YUY2
 
const int COLOR_BGR2YUV_YUYV = COLOR_BGR2YUV_YUY2
 
const int COLOR_RGB2YUV_YUNV = COLOR_RGB2YUV_YUY2
 
const int COLOR_BGR2YUV_YUNV = COLOR_BGR2YUV_YUY2
 
const int COLOR_RGBA2YUV_YUY2 = 151
 
const int COLOR_BGRA2YUV_YUY2 = 152
 
const int COLOR_RGBA2YUV_YVYU = 153
 
const int COLOR_BGRA2YUV_YVYU = 154
 
const int COLOR_RGBA2YUV_YUYV = COLOR_RGBA2YUV_YUY2
 
const int COLOR_BGRA2YUV_YUYV = COLOR_BGRA2YUV_YUY2
 
const int COLOR_RGBA2YUV_YUNV = COLOR_RGBA2YUV_YUY2
 
const int COLOR_BGRA2YUV_YUNV = COLOR_BGRA2YUV_YUY2
 
const int COLOR_COLORCVT_MAX = 155
 
const int COLORMAP_AUTUMN = 0
 
const int COLORMAP_BONE = 1
 
const int COLORMAP_JET = 2
 
const int COLORMAP_WINTER = 3
 
const int COLORMAP_RAINBOW = 4
 
const int COLORMAP_OCEAN = 5
 
const int COLORMAP_SUMMER = 6
 
const int COLORMAP_SPRING = 7
 
const int COLORMAP_COOL = 8
 
const int COLORMAP_HSV = 9
 
const int COLORMAP_PINK = 10
 
const int COLORMAP_HOT = 11
 
const int COLORMAP_PARULA = 12
 
const int COLORMAP_MAGMA = 13
 
const int COLORMAP_INFERNO = 14
 
const int COLORMAP_PLASMA = 15
 
const int COLORMAP_VIRIDIS = 16
 
const int COLORMAP_CIVIDIS = 17
 
const int COLORMAP_TWILIGHT = 18
 
const int COLORMAP_TWILIGHT_SHIFTED = 19
 
const int COLORMAP_TURBO = 20
 
const int COLORMAP_DEEPGREEN = 21
 
const int CCL_DEFAULT = -1
 
const int CCL_WU = 0
 
const int CCL_GRANA = 1
 
const int CCL_BOLELLI = 2
 
const int CCL_SAUF = 3
 
const int CCL_BBDT = 4
 
const int CCL_SPAGHETTI = 5
 
const int CC_STAT_LEFT = 0
 
const int CC_STAT_TOP = 1
 
const int CC_STAT_WIDTH = 2
 
const int CC_STAT_HEIGHT = 3
 
const int CC_STAT_AREA = 4
 
const int CC_STAT_MAX = 5
 
const int CHAIN_APPROX_NONE = 1
 
const int CHAIN_APPROX_SIMPLE = 2
 
const int CHAIN_APPROX_TC89_L1 = 3
 
const int CHAIN_APPROX_TC89_KCOS = 4
 
const int DIST_LABEL_CCOMP = 0
 
const int DIST_LABEL_PIXEL = 1
 
const int DIST_MASK_3 = 3
 
const int DIST_MASK_5 = 5
 
const int DIST_MASK_PRECISE = 0
 
const int DIST_USER = -1
 
const int DIST_L1 = 1
 
const int DIST_L2 = 2
 
const int DIST_C = 3
 
const int DIST_L12 = 4
 
const int DIST_FAIR = 5
 
const int DIST_WELSCH = 6
 
const int DIST_HUBER = 7
 
const int FLOODFILL_FIXED_RANGE = 1 << 16
 
const int FLOODFILL_MASK_ONLY = 1 << 17
 
const int GC_BGD = 0
 
const int GC_FGD = 1
 
const int GC_PR_BGD = 2
 
const int GC_PR_FGD = 3
 
const int GC_INIT_WITH_RECT = 0
 
const int GC_INIT_WITH_MASK = 1
 
const int GC_EVAL = 2
 
const int GC_EVAL_FREEZE_MODEL = 3
 
const int FONT_HERSHEY_SIMPLEX = 0
 
const int FONT_HERSHEY_PLAIN = 1
 
const int FONT_HERSHEY_DUPLEX = 2
 
const int FONT_HERSHEY_COMPLEX = 3
 
const int FONT_HERSHEY_TRIPLEX = 4
 
const int FONT_HERSHEY_COMPLEX_SMALL = 5
 
const int FONT_HERSHEY_SCRIPT_SIMPLEX = 6
 
const int FONT_HERSHEY_SCRIPT_COMPLEX = 7
 
const int FONT_ITALIC = 16
 
const int HISTCMP_CORREL = 0
 
const int HISTCMP_CHISQR = 1
 
const int HISTCMP_INTERSECT = 2
 
const int HISTCMP_BHATTACHARYYA = 3
 
const int HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA
 
const int HISTCMP_CHISQR_ALT = 4
 
const int HISTCMP_KL_DIV = 5
 
const int HOUGH_STANDARD = 0
 
const int HOUGH_PROBABILISTIC = 1
 
const int HOUGH_MULTI_SCALE = 2
 
const int HOUGH_GRADIENT = 3
 
const int HOUGH_GRADIENT_ALT = 4
 
const int INTER_NEAREST = 0
 
const int INTER_LINEAR = 1
 
const int INTER_CUBIC = 2
 
const int INTER_AREA = 3
 
const int INTER_LANCZOS4 = 4
 
const int INTER_LINEAR_EXACT = 5
 
const int INTER_NEAREST_EXACT = 6
 
const int INTER_MAX = 7
 
const int WARP_FILL_OUTLIERS = 8
 
const int WARP_INVERSE_MAP = 16
 
const int INTER_BITS = 5
 
const int INTER_BITS2 = INTER_BITS * 2
 
const int INTER_TAB_SIZE = 1 << INTER_BITS
 
const int INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
 
const int LSD_REFINE_NONE = 0
 
const int LSD_REFINE_STD = 1
 
const int LSD_REFINE_ADV = 2
 
const int FILLED = -1
 
const int LINE_4 = 4
 
const int LINE_8 = 8
 
const int LINE_AA = 16
 
const int MARKER_CROSS = 0
 
const int MARKER_TILTED_CROSS = 1
 
const int MARKER_STAR = 2
 
const int MARKER_DIAMOND = 3
 
const int MARKER_SQUARE = 4
 
const int MARKER_TRIANGLE_UP = 5
 
const int MARKER_TRIANGLE_DOWN = 6
 
const int MORPH_RECT = 0
 
const int MORPH_CROSS = 1
 
const int MORPH_ELLIPSE = 2
 
const int MORPH_ERODE = 0
 
const int MORPH_DILATE = 1
 
const int MORPH_OPEN = 2
 
const int MORPH_CLOSE = 3
 
const int MORPH_GRADIENT = 4
 
const int MORPH_TOPHAT = 5
 
const int MORPH_BLACKHAT = 6
 
const int MORPH_HITMISS = 7
 
const int INTERSECT_NONE = 0
 
const int INTERSECT_PARTIAL = 1
 
const int INTERSECT_FULL = 2
 
const int RETR_EXTERNAL = 0
 
const int RETR_LIST = 1
 
const int RETR_CCOMP = 2
 
const int RETR_TREE = 3
 
const int RETR_FLOODFILL = 4
 
const int CONTOURS_MATCH_I1 = 1
 
const int CONTOURS_MATCH_I2 = 2
 
const int CONTOURS_MATCH_I3 = 3
 
const int FILTER_SCHARR = -1
 
const int TM_SQDIFF = 0
 
const int TM_SQDIFF_NORMED = 1
 
const int TM_CCORR = 2
 
const int TM_CCORR_NORMED = 3
 
const int TM_CCOEFF = 4
 
const int TM_CCOEFF_NORMED = 5
 
const int THRESH_BINARY = 0
 
const int THRESH_BINARY_INV = 1
 
const int THRESH_TRUNC = 2
 
const int THRESH_TOZERO = 3
 
const int THRESH_TOZERO_INV = 4
 
const int THRESH_MASK = 7
 
const int THRESH_OTSU = 8
 
const int THRESH_TRIANGLE = 16
 
const int WARP_POLAR_LINEAR = 0
 
const int WARP_POLAR_LOG = 256
 

Member Function Documentation

◆ accumulate() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulate ( Mat  src,
Mat  dst,
Mat  mask 
)
static

Adds an image to the accumulator image.

The function adds src or some of its elements to dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

The function cv::accumulate can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

Parameters
srcInput image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.
dstAccumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulate() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulate ( Mat  src,
Mat  dst 
)
static

Adds an image to the accumulator image.

The function adds src or some of its elements to dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

The function cv::accumulate can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

Parameters
srcInput image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.
dstAccumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulateProduct() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateProduct ( Mat  src1,
Mat  src2,
Mat  dst,
Mat  mask 
)
static

Adds the per-element product of two input images to the accumulator image.

The function adds the product of two images or their selected regions to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
src1First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
src2Second input image of the same type and the same size as src1 .
dstAccumulator image with the same number of channels as input images, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateWeighted

◆ accumulateProduct() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateProduct ( Mat  src1,
Mat  src2,
Mat  dst 
)
static

Adds the per-element product of two input images to the accumulator image.

The function adds the product of two images or their selected regions to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
src1First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
src2Second input image of the same type and the same size as src1 .
dstAccumulator image with the same number of channels as input images, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateWeighted

◆ accumulateSquare() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateSquare ( Mat  src,
Mat  dst,
Mat  mask 
)
static

Adds the square of a source image to the accumulator image.

The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulateSquare() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateSquare ( Mat  src,
Mat  dst 
)
static

Adds the square of a source image to the accumulator image.

The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulateWeighted() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateWeighted ( Mat  src,
Mat  dst,
double  alpha,
Mat  mask 
)
static

Updates a running average.

The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence:

\[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
alphaWeight of the input image.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateProduct

◆ accumulateWeighted() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.accumulateWeighted ( Mat  src,
Mat  dst,
double  alpha 
)
static

Updates a running average.

The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence:

\[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
alphaWeight of the input image.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateProduct

◆ adaptiveThreshold()

static void OpenCVForUnity.ImgprocModule.Imgproc.adaptiveThreshold ( Mat  src,
Mat  dst,
double  maxValue,
int  adaptiveMethod,
int  thresholdType,
int  blockSize,
double  C 
)
static

Applies an adaptive threshold to an array.

The function transforms a grayscale image to a binary image according to the formulae:

  • THRESH_BINARY

    \[dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\]

  • THRESH_BINARY_INV

    \[dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\]

    where \(T(x,y)\) is a threshold calculated individually for each pixel (see adaptiveMethod parameter).

The function can process the image in-place.

Parameters
srcSource 8-bit single-channel image.
dstDestination image of the same size and the same type as src.
maxValueNon-zero value assigned to the pixels for which the condition is satisfied
adaptiveMethodAdaptive thresholding algorithm to use, see #AdaptiveThresholdTypes. The #BORDER_REPLICATE | #BORDER_ISOLATED is used to process boundaries.
thresholdTypeThresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV, see #ThresholdTypes.
blockSizeSize of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
CConstant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.
See also
threshold, blur, GaussianBlur

◆ applyColorMap() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.applyColorMap ( Mat  src,
Mat  dst,
int  colormap 
)
static

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

Parameters
srcThe source image, grayscale or colored of type CV_8UC1 or CV_8UC3.
dstThe result is the colormapped source image. Note: Mat::create is called on dst.
colormapThe colormap to apply, see #ColormapTypes

◆ applyColorMap() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.applyColorMap ( Mat  src,
Mat  dst,
Mat  userColor 
)
static

Applies a user colormap on a given image.

Parameters
srcThe source image, grayscale or colored of type CV_8UC1 or CV_8UC3.
dstThe result is the colormapped source image. Note: Mat::create is called on dst.
userColorThe colormap to apply of type CV_8UC1 or CV_8UC3 and size 256

◆ approxPolyDP()

static void OpenCVForUnity.ImgprocModule.Imgproc.approxPolyDP ( MatOfPoint2f  curve,
MatOfPoint2f  approxCurve,
double  epsilon,
bool  closed 
)
static

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

The function cv::approxPolyDP approximates a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm <http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm&gt;

Parameters
curveInput vector of a 2D point stored in std::vector or Mat
approxCurveResult of the approximation. The type should match the type of the input curve.
epsilonParameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.
closedIf true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

◆ arcLength()

static double OpenCVForUnity.ImgprocModule.Imgproc.arcLength ( MatOfPoint2f  curve,
bool  closed 
)
static

Calculates a contour perimeter or a curve length.

The function computes a curve length or a closed contour perimeter.

Parameters
curveInput vector of 2D points, stored in std::vector or Mat.
closedFlag indicating whether the curve is closed or not.

◆ arrowedLine() [1/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.arrowedLine ( Mat  img,
Point  pt1,
Point  pt2,
Scalar  color,
int  thickness,
int  line_type,
int  shift,
double  tipLength 
)
static

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

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.

Parameters
imgImage.
pt1The point the arrow starts from.
pt2The point the arrow points to.
colorLine color.
thicknessLine thickness.
line_typeType of the line. See #LineTypes
shiftNumber of fractional bits in the point coordinates.
tipLengthThe length of the arrow tip in relation to the arrow length

◆ arrowedLine() [2/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.arrowedLine ( Mat  img,
Point  pt1,
Point  pt2,
Scalar  color,
int  thickness,
int  line_type,
int  shift 
)
static

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

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.

Parameters
imgImage.
pt1The point the arrow starts from.
pt2The point the arrow points to.
colorLine color.
thicknessLine thickness.
line_typeType of the line. See #LineTypes
shiftNumber of fractional bits in the point coordinates.
tipLengthThe length of the arrow tip in relation to the arrow length

◆ arrowedLine() [3/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.arrowedLine ( Mat  img,
Point  pt1,
Point  pt2,
Scalar  color,
int  thickness,
int  line_type 
)
static

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

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.

Parameters
imgImage.
pt1The point the arrow starts from.
pt2The point the arrow points to.
colorLine color.
thicknessLine thickness.
line_typeType of the line. See #LineTypes
shiftNumber of fractional bits in the point coordinates.
tipLengthThe length of the arrow tip in relation to the arrow length

◆ arrowedLine() [4/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.arrowedLine ( Mat  img,
Point  pt1,
Point  pt2,
Scalar  color,
int  thickness 
)
static

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

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.

Parameters
imgImage.
pt1The point the arrow starts from.
pt2The point the arrow points to.
colorLine color.
thicknessLine thickness.
line_typeType of the line. See #LineTypes
shiftNumber of fractional bits in the point coordinates.
tipLengthThe length of the arrow tip in relation to the arrow length

◆ arrowedLine() [5/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.arrowedLine ( Mat  img,
Point  pt1,
Point  pt2,
Scalar  color 
)
static

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

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.

Parameters
imgImage.
pt1The point the arrow starts from.
pt2The point the arrow points to.
colorLine color.
thicknessLine thickness.
line_typeType of the line. See #LineTypes
shiftNumber of fractional bits in the point coordinates.
tipLengthThe length of the arrow tip in relation to the arrow length

◆ bilateralFilter() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.bilateralFilter ( Mat  src,
Mat  dst,
int  d,
double  sigmaColor,
double  sigmaSpace,
int  borderType 
)
static

Applies the bilateral filter to an image.

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish".

Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.

This filter does not work inplace.

Parameters
srcSource 8-bit or floating-point, 1-channel or 3-channel image.
dstDestination image of the same size and type as src .
dDiameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.
sigmaColorFilter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpaceFilter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes

◆ bilateralFilter() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.bilateralFilter ( Mat  src,
Mat  dst,
int  d,
double  sigmaColor,
double  sigmaSpace 
)
static

Applies the bilateral filter to an image.

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish".

Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.

This filter does not work inplace.

Parameters
srcSource 8-bit or floating-point, 1-channel or 3-channel image.
dstDestination image of the same size and type as src .
dDiameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.
sigmaColorFilter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpaceFilter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes

◆ blendLinear()

static void OpenCVForUnity.ImgprocModule.Imgproc.blendLinear ( Mat  src1,
Mat  src2,
Mat  weights1,
Mat  weights2,
Mat  dst 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

variant without mask parameter

◆ blur() [1/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.blur ( Mat  src,
Mat  dst,
Size  ksize,
Point  anchor,
int  borderType 
)
static

Blurs an image using the normalized box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\]

The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), ksize, anchor, true, borderType).

Parameters
srcinput image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
boxFilter, bilateralFilter, GaussianBlur, medianBlur

◆ blur() [2/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.blur ( Mat  src,
Mat  dst,
Size  ksize,
Point  anchor 
)
static

Blurs an image using the normalized box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\]

The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), ksize, anchor, true, borderType).

Parameters
srcinput image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
boxFilter, bilateralFilter, GaussianBlur, medianBlur

◆ blur() [3/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.blur ( Mat  src,
Mat  dst,
Size  ksize 
)
static

Blurs an image using the normalized box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\]

The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), ksize, anchor, true, borderType).

Parameters
srcinput image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
boxFilter, bilateralFilter, GaussianBlur, medianBlur

◆ boundingRect()

static Rect OpenCVForUnity.ImgprocModule.Imgproc.boundingRect ( Mat  array)
static

Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.

The function calculates and returns the minimal up-right bounding rectangle for the specified point set or non-zero pixels of gray-scale image.

Parameters
arrayInput gray-scale image or 2D point set, stored in std::vector or Mat.

◆ boxFilter() [1/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.boxFilter ( Mat  src,
Mat  dst,
int  ddepth,
Size  ksize,
Point  anchor,
bool  normalize,
int  borderType 
)
static

Blurs an image using the box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

where

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\]

Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use integral.

Parameters
srcinput image.
dstoutput image of the same size and type as src.
ddepththe output image depth (-1 to use src.depth()).
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalizeflag, specifying whether the kernel is normalized by its area or not.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
blur, bilateralFilter, GaussianBlur, medianBlur, integral

◆ boxFilter() [2/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.boxFilter ( Mat  src,
Mat  dst,
int  ddepth,
Size  ksize,
Point  anchor,
bool  normalize 
)
static

Blurs an image using the box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

where

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\]

Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use integral.

Parameters
srcinput image.
dstoutput image of the same size and type as src.
ddepththe output image depth (-1 to use src.depth()).
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalizeflag, specifying whether the kernel is normalized by its area or not.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
blur, bilateralFilter, GaussianBlur, medianBlur, integral

◆ boxFilter() [3/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.boxFilter ( Mat  src,
Mat  dst,
int  ddepth,
Size  ksize,
Point  anchor 
)
static

Blurs an image using the box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

where

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\]

Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use integral.

Parameters
srcinput image.
dstoutput image of the same size and type as src.
ddepththe output image depth (-1 to use src.depth()).
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalizeflag, specifying whether the kernel is normalized by its area or not.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
blur, bilateralFilter, GaussianBlur, medianBlur, integral

◆ boxFilter() [4/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.boxFilter ( Mat  src,
Mat  dst,
int  ddepth,
Size  ksize 
)
static

Blurs an image using the box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

where

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\]

Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use integral.

Parameters
srcinput image.
dstoutput image of the same size and type as src.
ddepththe output image depth (-1 to use src.depth()).
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalizeflag, specifying whether the kernel is normalized by its area or not.
borderTypeborder mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
See also
blur, bilateralFilter, GaussianBlur, medianBlur, integral

◆ boxPoints()

static void OpenCVForUnity.ImgprocModule.Imgproc.boxPoints ( RotatedRect  box,
Mat  points 
)
static

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

The function finds the four vertices of a rotated rectangle. This function is useful to draw the rectangle. In C++, instead of using this function, you can directly use RotatedRect::points method. Please visit the tutorial on Creating Bounding rotated boxes and ellipses for contours for more information.

Parameters
boxThe input rotated rectangle. It may be the output of minAreaRect.
pointsThe output array of four vertices of rectangles.

◆ calcBackProject()

static void OpenCVForUnity.ImgprocModule.Imgproc.calcBackProject ( List< Mat images,
MatOfInt  channels,
Mat  hist,
Mat  dst,
MatOfFloat  ranges,
double  scale 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ calcHist() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.calcHist ( List< Mat images,
MatOfInt  channels,
Mat  mask,
Mat  hist,
MatOfInt  histSize,
MatOfFloat  ranges,
bool  accumulate 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

this variant supports only uniform histograms.

ranges argument is either empty vector or a flattened vector of histSize.size()*2 elements (histSize.size() element pairs). The first and second elements of each pair specify the lower and upper boundaries.

◆ calcHist() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.calcHist ( List< Mat images,
MatOfInt  channels,
Mat  mask,
Mat  hist,
MatOfInt  histSize,
MatOfFloat  ranges 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

this variant supports only uniform histograms.

ranges argument is either empty vector or a flattened vector of histSize.size()*2 elements (histSize.size() element pairs). The first and second elements of each pair specify the lower and upper boundaries.

◆ Canny() [1/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.Canny ( Mat  image,
Mat  edges,
double  threshold1,
double  threshold2,
int  apertureSize,
bool  L2gradient 
)
static

Finds edges in an image using the Canny algorithm [Canny86] .

The function finds edges in the input image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See <http://en.wikipedia.org/wiki/Canny_edge_detector&gt;

Parameters
image8-bit input image.
edgesoutput edge map; single channels 8-bit image, which has the same size as image .
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
apertureSizeaperture size for the Sobel operator.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ Canny() [2/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.Canny ( Mat  image,
Mat  edges,
double  threshold1,
double  threshold2,
int  apertureSize 
)
static

Finds edges in an image using the Canny algorithm [Canny86] .

The function finds edges in the input image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See <http://en.wikipedia.org/wiki/Canny_edge_detector&gt;

Parameters
image8-bit input image.
edgesoutput edge map; single channels 8-bit image, which has the same size as image .
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
apertureSizeaperture size for the Sobel operator.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ Canny() [3/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.Canny ( Mat  image,
Mat  edges,
double  threshold1,
double  threshold2 
)
static

Finds edges in an image using the Canny algorithm [Canny86] .

The function finds edges in the input image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See <http://en.wikipedia.org/wiki/Canny_edge_detector&gt;

Parameters
image8-bit input image.
edgesoutput edge map; single channels 8-bit image, which has the same size as image .
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
apertureSizeaperture size for the Sobel operator.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ Canny() [4/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.Canny ( Mat  dx,
Mat  dy,
Mat  edges,
double  threshold1,
double  threshold2,
bool  L2gradient 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Finds edges in an image using the Canny algorithm with custom image gradient.

Parameters
dx16-bit x derivative of input image (CV_16SC1 or CV_16SC3).
dy16-bit y derivative of input image (same type as dx).
edgesoutput edge map; single channels 8-bit image, which has the same size as image .
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ Canny() [5/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.Canny ( Mat  dx,
Mat  dy,
Mat  edges,
double  threshold1,
double  threshold2 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Finds edges in an image using the Canny algorithm with custom image gradient.

Parameters
dx16-bit x derivative of input image (CV_16SC1 or CV_16SC3).
dy16-bit y derivative of input image (same type as dx).
edgesoutput edge map; single channels 8-bit image, which has the same size as image .
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ circle() [1/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.circle ( Mat  img,
Point  center,
int  radius,
Scalar  color,
int  thickness,
int  lineType,
int  shift 
)
static

Draws a circle.

The function cv::circle draws a simple or filled circle with a given center and radius.

Parameters
imgImage where the circle is drawn.
centerCenter of the circle.
radiusRadius of the circle.
colorCircle color.
thicknessThickness of the circle outline, if positive. Negative values, like FILLED, mean that a filled circle is to be drawn.
lineTypeType of the circle boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and in the radius value.

◆ circle() [2/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.circle ( Mat  img,
Point  center,
int  radius,
Scalar  color,
int  thickness,
int  lineType 
)
static

Draws a circle.

The function cv::circle draws a simple or filled circle with a given center and radius.

Parameters
imgImage where the circle is drawn.
centerCenter of the circle.
radiusRadius of the circle.
colorCircle color.
thicknessThickness of the circle outline, if positive. Negative values, like FILLED, mean that a filled circle is to be drawn.
lineTypeType of the circle boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and in the radius value.

◆ circle() [3/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.circle ( Mat  img,
Point  center,
int  radius,
Scalar  color,
int  thickness 
)
static

Draws a circle.

The function cv::circle draws a simple or filled circle with a given center and radius.

Parameters
imgImage where the circle is drawn.
centerCenter of the circle.
radiusRadius of the circle.
colorCircle color.
thicknessThickness of the circle outline, if positive. Negative values, like FILLED, mean that a filled circle is to be drawn.
lineTypeType of the circle boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and in the radius value.

◆ circle() [4/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.circle ( Mat  img,
Point  center,
int  radius,
Scalar  color 
)
static

Draws a circle.

The function cv::circle draws a simple or filled circle with a given center and radius.

Parameters
imgImage where the circle is drawn.
centerCenter of the circle.
radiusRadius of the circle.
colorCircle color.
thicknessThickness of the circle outline, if positive. Negative values, like FILLED, mean that a filled circle is to be drawn.
lineTypeType of the circle boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and in the radius value.

◆ clipLine()

static bool OpenCVForUnity.ImgprocModule.Imgproc.clipLine ( Rect  imgRect,
Point  pt1,
Point  pt2 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imgRectImage rectangle.
pt1First line point.
pt2Second line point.

◆ compareHist()

static double OpenCVForUnity.ImgprocModule.Imgproc.compareHist ( Mat  H1,
Mat  H2,
int  method 
)
static

Compares two histograms.

The function cv::compareHist compares two dense or two sparse histograms using the specified method.

The function returns \(d(H_1, H_2)\) .

While the function works well with 1-, 2-, 3-dimensional dense histograms, it may not be suitable for high-dimensional sparse histograms. In such histograms, because of aliasing and sampling problems, the coordinates of non-zero histogram bins can slightly shift. To compare such histograms or more general sparse configurations of weighted points, consider using the EMD function.

Parameters
H1First compared histogram.
H2Second compared histogram of the same size as H1 .
methodComparison method, see #HistCompMethods

◆ connectedComponents() [1/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponents ( Mat  image,
Mat  labels,
int  connectivity,
int  ltype 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponents() [2/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponents ( Mat  image,
Mat  labels,
int  connectivity 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponents() [3/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponents ( Mat  image,
Mat  labels 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponentsWithAlgorithm()

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponentsWithAlgorithm ( Mat  image,
Mat  labels,
int  connectivity,
int  ltype,
int  ccltype 
)
static

computes the connected components labeled image of boolean image

image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image. ccltype specifies the connected components labeling algorithm to use, currently Bolelli (Spaghetti) [Bolelli2019], Grana (BBDT) [Grana2010] and Wu's (SAUF) [Wu2009] algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces a row major ordering of labels while Spaghetti and BBDT do not. This function uses parallel version of the algorithms if at least one allowed parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.
ccltypeconnected components algorithm type (see the #ConnectedComponentsAlgorithmsTypes).

◆ connectedComponentsWithStats() [1/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponentsWithStats ( Mat  image,
Mat  labels,
Mat  stats,
Mat  centroids,
int  connectivity,
int  ltype 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
statsstatistics output for each label, including the background label. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of #ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
centroidscentroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponentsWithStats() [2/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponentsWithStats ( Mat  image,
Mat  labels,
Mat  stats,
Mat  centroids,
int  connectivity 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
statsstatistics output for each label, including the background label. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of #ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
centroidscentroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponentsWithStats() [3/3]

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponentsWithStats ( Mat  image,
Mat  labels,
Mat  stats,
Mat  centroids 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
statsstatistics output for each label, including the background label. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of #ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
centroidscentroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.

◆ connectedComponentsWithStatsWithAlgorithm()

static int OpenCVForUnity.ImgprocModule.Imgproc.connectedComponentsWithStatsWithAlgorithm ( Mat  image,
Mat  labels,
Mat  stats,
Mat  centroids,
int  connectivity,
int  ltype,
int  ccltype 
)
static

computes the connected components labeled image of boolean image and also produces a statistics output for each label

image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image. ccltype specifies the connected components labeling algorithm to use, currently Bolelli (Spaghetti) [Bolelli2019], Grana (BBDT) [Grana2010] and Wu's (SAUF) [Wu2009] algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces a row major ordering of labels while Spaghetti and BBDT do not. This function uses parallel version of the algorithms (statistics included) if at least one allowed parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.

Parameters
imagethe 8-bit single-channel image to be labeled
labelsdestination labeled image
statsstatistics output for each label, including the background label. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of #ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
centroidscentroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
connectivity8 or 4 for 8-way or 4-way connectivity respectively
ltypeoutput image label type. Currently CV_32S and CV_16U are supported.
ccltypeconnected components algorithm type (see #ConnectedComponentsAlgorithmsTypes).

◆ contourArea() [1/2]

static double OpenCVForUnity.ImgprocModule.Imgproc.contourArea ( Mat  contour,
bool  oriented 
)
static

Calculates a contour area.

The function computes a contour area. Similarly to moments , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using drawContours or fillPoly , can be different. Also, the function will most certainly give a wrong results for contours with self-intersections.

Example:

vector&lt;Point&gt; contour;
contour.push_back(Point2f(0, 0));
contour.push_back(Point2f(10, 0));
contour.push_back(Point2f(10, 10));
contour.push_back(Point2f(5, 4));
double area0 = contourArea(contour);
vector&lt;Point&gt; approx;
approxPolyDP(contour, approx, 5, true);
double area1 = contourArea(approx);
cout &lt;&lt; "area0 =" &lt;&lt; area0 &lt;&lt; endl &lt;&lt;
"area1 =" &lt;&lt; area1 &lt;&lt; endl &lt;&lt;
"approx poly vertices" &lt;&lt; approx.size() &lt;&lt; endl;
Parameters
contourInput vector of 2D points (contour vertices), stored in std::vector or Mat.
orientedOriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is false, which means that the absolute value is returned.

◆ contourArea() [2/2]

static double OpenCVForUnity.ImgprocModule.Imgproc.contourArea ( Mat  contour)
static

Calculates a contour area.

The function computes a contour area. Similarly to moments , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using drawContours or fillPoly , can be different. Also, the function will most certainly give a wrong results for contours with self-intersections.

Example:

vector&lt;Point&gt; contour;
contour.push_back(Point2f(0, 0));
contour.push_back(Point2f(10, 0));
contour.push_back(Point2f(10, 10));
contour.push_back(Point2f(5, 4));
double area0 = contourArea(contour);
vector&lt;Point&gt; approx;
approxPolyDP(contour, approx, 5, true);
double area1 = contourArea(approx);
cout &lt;&lt; "area0 =" &lt;&lt; area0 &lt;&lt; endl &lt;&lt;
"area1 =" &lt;&lt; area1 &lt;&lt; endl &lt;&lt;
"approx poly vertices" &lt;&lt; approx.size() &lt;&lt; endl;
Parameters
contourInput vector of 2D points (contour vertices), stored in std::vector or Mat.
orientedOriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is false, which means that the absolute value is returned.

◆ convertMaps() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.convertMaps ( Mat  map1,
Mat  map2,
Mat  dstmap1,
Mat  dstmap2,
int  dstmap1type,
bool  nninterpolation 
)
static

Converts image transformation maps from one representation to another.

The function converts a pair of maps for remap from one representation to another. The following options ( (map1.type(), map2.type()) \(\rightarrow\) (dstmap1.type(), dstmap2.type()) ) are supported:

  • \(\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\). This is the most frequently used conversion operation, in which the original floating-point maps (see remap) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when nninterpolation=false ) contains indices in the interpolation tables.
  • \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\). The same as above but the original maps are stored in one 2-channel matrix.
  • Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals.
Parameters
map1The first input map of type CV_16SC2, CV_32FC1, or CV_32FC2 .
map2The second input map of type CV_16UC1, CV_32FC1, or none (empty matrix), respectively.
dstmap1The first output map that has the type dstmap1type and the same size as src .
dstmap2The second output map.
dstmap1typeType of the first output map that should be CV_16SC2, CV_32FC1, or CV_32FC2 .
nninterpolationFlag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.
See also
remap, undistort, initUndistortRectifyMap

◆ convertMaps() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.convertMaps ( Mat  map1,
Mat  map2,
Mat  dstmap1,
Mat  dstmap2,
int  dstmap1type 
)
static

Converts image transformation maps from one representation to another.

The function converts a pair of maps for remap from one representation to another. The following options ( (map1.type(), map2.type()) \(\rightarrow\) (dstmap1.type(), dstmap2.type()) ) are supported:

  • \(\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\). This is the most frequently used conversion operation, in which the original floating-point maps (see remap) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when nninterpolation=false ) contains indices in the interpolation tables.
  • \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\). The same as above but the original maps are stored in one 2-channel matrix.
  • Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals.
Parameters
map1The first input map of type CV_16SC2, CV_32FC1, or CV_32FC2 .
map2The second input map of type CV_16UC1, CV_32FC1, or none (empty matrix), respectively.
dstmap1The first output map that has the type dstmap1type and the same size as src .
dstmap2The second output map.
dstmap1typeType of the first output map that should be CV_16SC2, CV_32FC1, or CV_32FC2 .
nninterpolationFlag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.
See also
remap, undistort, initUndistortRectifyMap

◆ convexHull() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.convexHull ( MatOfPoint  points,
MatOfInt  hull,
bool  clockwise 
)
static

Finds the convex hull of a point set.

The function cv::convexHull finds the convex hull of a 2D point set using the Sklansky's algorithm [Sklansky82] that has O(N logN) complexity in the current implementation.

Parameters
pointsInput 2D point set, stored in std::vector or Mat.
hullOutput convex hull. It is either an integer vector of indices or vector of points. In the first case, the hull elements are 0-based indices of the convex hull points in the original array (since the set of convex hull points is a subset of the original point set). In the second case, hull elements are the convex hull points themselves.
clockwiseOrientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.
returnPointsOperation flag. In case of a matrix, when the flag is true, the function returns convex hull points. Otherwise, it returns indices of the convex hull points. When the output array is std::vector, the flag is ignored, and the output depends on the type of the vector: std::vector<int> implies returnPoints=false, std::vector<Point> implies returnPoints=true.
Note
points and hull should be different arrays, inplace processing isn't supported.

Check the corresponding tutorial for more details.

useful links:

https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/

◆ convexHull() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.convexHull ( MatOfPoint  points,
MatOfInt  hull 
)
static

Finds the convex hull of a point set.

The function cv::convexHull finds the convex hull of a 2D point set using the Sklansky's algorithm [Sklansky82] that has O(N logN) complexity in the current implementation.

Parameters
pointsInput 2D point set, stored in std::vector or Mat.
hullOutput convex hull. It is either an integer vector of indices or vector of points. In the first case, the hull elements are 0-based indices of the convex hull points in the original array (since the set of convex hull points is a subset of the original point set). In the second case, hull elements are the convex hull points themselves.
clockwiseOrientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.
returnPointsOperation flag. In case of a matrix, when the flag is true, the function returns convex hull points. Otherwise, it returns indices of the convex hull points. When the output array is std::vector, the flag is ignored, and the output depends on the type of the vector: std::vector<int> implies returnPoints=false, std::vector<Point> implies returnPoints=true.
Note
points and hull should be different arrays, inplace processing isn't supported.

Check the corresponding tutorial for more details.

useful links:

https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/

◆ convexityDefects()

static void OpenCVForUnity.ImgprocModule.Imgproc.convexityDefects ( MatOfPoint  contour,
MatOfInt  convexhull,
MatOfInt4  convexityDefects 
)
static

Finds the convexity defects of a contour.

The figure below displays convexity defects of a hand contour:

defects.png
image
Parameters
contourInput contour.
convexhullConvex hull obtained using convexHull that should contain indices of the contour points that make the hull.
convexityDefectsThe output vector of convexity defects. In C++ and the new Python/Java interface each convexity defect is represented as 4-element integer vector (a.k.a. #Vec4i): (start_index, end_index, farthest_pt_index, fixpt_depth), where indices are 0-based indices in the original contour of the convexity defect beginning, end and the farthest point, and fixpt_depth is fixed-point approximation (with 8 fractional bits) of the distance between the farthest contour point and the hull. That is, to get the floating-point value of the depth will be fixpt_depth/256.0.

◆ cornerEigenValsAndVecs() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerEigenValsAndVecs ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize,
int  borderType 
)
static

Calculates eigenvalues and eigenvectors of image blocks for corner detection.

For every pixel \(p\) , the function cornerEigenValsAndVecs considers a blockSize \(\times\) blockSize neighborhood \(S(p)\) . It calculates the covariation matrix of derivatives over the neighborhood as:

\[M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\]

where the derivatives are computed using the Sobel operator.

After that, it finds eigenvectors and eigenvalues of \(M\) and stores them in the destination image as \((\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\) where

  • \(\lambda_1, \lambda_2\) are the non-sorted eigenvalues of \(M\)
  • \(x_1, y_1\) are the eigenvectors corresponding to \(\lambda_1\)
  • \(x_2, y_2\) are the eigenvectors corresponding to \(\lambda_2\)

The output of the function can be used for robust edge or corner detection.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the results. It has the same size as src and the type CV_32FC(6) .
blockSizeNeighborhood size (see details below).
ksizeAperture parameter for the Sobel operator.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
See also
cornerMinEigenVal, cornerHarris, preCornerDetect

◆ cornerEigenValsAndVecs() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerEigenValsAndVecs ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize 
)
static

Calculates eigenvalues and eigenvectors of image blocks for corner detection.

For every pixel \(p\) , the function cornerEigenValsAndVecs considers a blockSize \(\times\) blockSize neighborhood \(S(p)\) . It calculates the covariation matrix of derivatives over the neighborhood as:

\[M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\]

where the derivatives are computed using the Sobel operator.

After that, it finds eigenvectors and eigenvalues of \(M\) and stores them in the destination image as \((\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\) where

  • \(\lambda_1, \lambda_2\) are the non-sorted eigenvalues of \(M\)
  • \(x_1, y_1\) are the eigenvectors corresponding to \(\lambda_1\)
  • \(x_2, y_2\) are the eigenvectors corresponding to \(\lambda_2\)

The output of the function can be used for robust edge or corner detection.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the results. It has the same size as src and the type CV_32FC(6) .
blockSizeNeighborhood size (see details below).
ksizeAperture parameter for the Sobel operator.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
See also
cornerMinEigenVal, cornerHarris, preCornerDetect

◆ cornerHarris() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerHarris ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize,
double  k,
int  borderType 
)
static

Harris corner detector.

The function runs the Harris corner detector on the image. Similarly to cornerMinEigenVal and cornerEigenValsAndVecs , for each pixel \((x, y)\) it calculates a \(2\times2\) gradient covariance matrix \(M^{(x,y)}\) over a \(\texttt{blockSize} \times \texttt{blockSize}\) neighborhood. Then, it computes the following characteristic:

\[\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\]

Corners in the image can be found as the local maxima of this response map.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the Harris detector responses. It has the type CV_32FC1 and the same size as src .
blockSizeNeighborhood size (see the details on cornerEigenValsAndVecs ).
ksizeAperture parameter for the Sobel operator.
kHarris detector free parameter. See the formula above.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

◆ cornerHarris() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerHarris ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize,
double  k 
)
static

Harris corner detector.

The function runs the Harris corner detector on the image. Similarly to cornerMinEigenVal and cornerEigenValsAndVecs , for each pixel \((x, y)\) it calculates a \(2\times2\) gradient covariance matrix \(M^{(x,y)}\) over a \(\texttt{blockSize} \times \texttt{blockSize}\) neighborhood. Then, it computes the following characteristic:

\[\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\]

Corners in the image can be found as the local maxima of this response map.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the Harris detector responses. It has the type CV_32FC1 and the same size as src .
blockSizeNeighborhood size (see the details on cornerEigenValsAndVecs ).
ksizeAperture parameter for the Sobel operator.
kHarris detector free parameter. See the formula above.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

◆ cornerMinEigenVal() [1/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerMinEigenVal ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize,
int  borderType 
)
static

Calculates the minimal eigenvalue of gradient matrices for corner detection.

The function is similar to cornerEigenValsAndVecs but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is, \(\min(\lambda_1, \lambda_2)\) in terms of the formulae in the cornerEigenValsAndVecs description.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as src .
blockSizeNeighborhood size (see the details on cornerEigenValsAndVecs ).
ksizeAperture parameter for the Sobel operator.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

◆ cornerMinEigenVal() [2/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerMinEigenVal ( Mat  src,
Mat  dst,
int  blockSize,
int  ksize 
)
static

Calculates the minimal eigenvalue of gradient matrices for corner detection.

The function is similar to cornerEigenValsAndVecs but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is, \(\min(\lambda_1, \lambda_2)\) in terms of the formulae in the cornerEigenValsAndVecs description.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as src .
blockSizeNeighborhood size (see the details on cornerEigenValsAndVecs ).
ksizeAperture parameter for the Sobel operator.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

◆ cornerMinEigenVal() [3/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerMinEigenVal ( Mat  src,
Mat  dst,
int  blockSize 
)
static

Calculates the minimal eigenvalue of gradient matrices for corner detection.

The function is similar to cornerEigenValsAndVecs but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is, \(\min(\lambda_1, \lambda_2)\) in terms of the formulae in the cornerEigenValsAndVecs description.

Parameters
srcInput single-channel 8-bit or floating-point image.
dstImage to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as src .
blockSizeNeighborhood size (see the details on cornerEigenValsAndVecs ).
ksizeAperture parameter for the Sobel operator.
borderTypePixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.

◆ cornerSubPix()

static void OpenCVForUnity.ImgprocModule.Imgproc.cornerSubPix ( Mat  image,
Mat  corners,
Size  winSize,
Size  zeroZone,
TermCriteria  criteria 
)
static

Refines the corner locations.

The function iterates to find the sub-pixel accurate location of corners or radial saddle points as described in [forstner1987fast], and as shown on the figure below.

cornersubpix.png
image

Sub-pixel accurate corner locator is based on the observation that every vector from the center \(q\) to a point \(p\) located within a neighborhood of \(q\) is orthogonal to the image gradient at \(p\) subject to image and measurement noise. Consider the expression:

\[\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)\]

where \({DI_{p_i}}\) is an image gradient at one of the points \(p_i\) in a neighborhood of \(q\) . The value of \(q\) is to be found so that \(\epsilon_i\) is minimized. A system of equations may be set up with \(\epsilon_i\) set to zero:

\[\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) \cdot q - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)\]

where the gradients are summed within a neighborhood ("search window") of \(q\) . Calling the first gradient term \(G\) and the second gradient term \(b\) gives:

\[q = G^{-1} \cdot b\]

The algorithm sets the center of the neighborhood window at this new center \(q\) and then iterates until the center stays within a set threshold.

Parameters
imageInput single-channel, 8-bit or float image.
cornersInitial coordinates of the input corners and refined coordinates provided for output.
winSizeHalf of the side length of the search window. For example, if winSize=Size(5,5) , then a \((5*2+1) \times (5*2+1) = 11 \times 11\) search window is used.
zeroZoneHalf of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such a size.
criteriaCriteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after criteria.maxCount iterations or when the corner position moves by less than criteria.epsilon on some iteration.

◆ createCLAHE() [1/3]

static CLAHE OpenCVForUnity.ImgprocModule.Imgproc.createCLAHE ( double  clipLimit,
Size  tileGridSize 
)
static

Creates a smart pointer to a cv::CLAHE class and initializes it.

Parameters
clipLimitThreshold for contrast limiting.
tileGridSizeSize of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.

◆ createCLAHE() [2/3]

static CLAHE OpenCVForUnity.ImgprocModule.Imgproc.createCLAHE ( double  clipLimit)
static

Creates a smart pointer to a cv::CLAHE class and initializes it.

Parameters
clipLimitThreshold for contrast limiting.
tileGridSizeSize of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.

◆ createCLAHE() [3/3]

static CLAHE OpenCVForUnity.ImgprocModule.Imgproc.createCLAHE ( )
static

Creates a smart pointer to a cv::CLAHE class and initializes it.

Parameters
clipLimitThreshold for contrast limiting.
tileGridSizeSize of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.

◆ createGeneralizedHoughBallard()

static GeneralizedHoughBallard OpenCVForUnity.ImgprocModule.Imgproc.createGeneralizedHoughBallard ( )
static

Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.

◆ createGeneralizedHoughGuil()

static GeneralizedHoughGuil OpenCVForUnity.ImgprocModule.Imgproc.createGeneralizedHoughGuil ( )
static

Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it.

◆ createHanningWindow()

static void OpenCVForUnity.ImgprocModule.Imgproc.createHanningWindow ( Mat  dst,
Size  winSize,
int  type 
)
static

This function computes a Hanning window coefficients in two dimensions.

See (http://en.wikipedia.org/wiki/Hann_function) and (http://en.wikipedia.org/wiki/Window_function) for more information.

An example is shown below:

// create hanning window of size 100x100 and type CV_32F
Mat hann;
createHanningWindow(hann, Size(100, 100), CV_32F);
Parameters
dstDestination array to place Hann coefficients in
winSizeThe window size specifications (both width and height must be > 1)
typeCreated array type

◆ createLineSegmentDetector() [1/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale,
double  quant,
double  ang_th,
double  log_eps,
double  density_th,
int  n_bins 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [2/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale,
double  quant,
double  ang_th,
double  log_eps,
double  density_th 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [3/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale,
double  quant,
double  ang_th,
double  log_eps 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [4/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale,
double  quant,
double  ang_th 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [5/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale,
double  quant 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [6/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale,
double  sigma_scale 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [7/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine,
double  scale 
)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [8/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( int  refine)
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ createLineSegmentDetector() [9/9]

static LineSegmentDetector OpenCVForUnity.ImgprocModule.Imgproc.createLineSegmentDetector ( )
static

Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters
refineThe way found lines will be refined, see #LineSegmentDetectorModes
scaleThe scale of the image that will be used to find the lines. Range (0..1].
sigma_scaleSigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
quantBound to the quantization error on the gradient norm.
ang_thGradient angle tolerance in degrees.
log_epsDetection threshold: -log10(NFA) > log_eps. Used only when advance refinement is chosen.
density_thMinimal density of aligned region points in the enclosing rectangle.
n_binsNumber of bins in pseudo-ordering of gradient modulus.

◆ cvtColor() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cvtColor ( Mat  src,
Mat  dst,
int  code,
int  dstCn 
)
static

Converts an image from one color space to another.

The function converts an input image from one color space to another. In case of a transformation to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR). Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.

The conventional ranges for R, G, and B channel values are:

  • 0 to 255 for CV_8U images
  • 0 to 65535 for CV_16U images
  • 0 to 1 for CV_32F images

In case of linear transformations, the range does not matter. But in case of a non-linear transformation, an input RGB image should be normalized to the proper value range to get the correct results, for example, for RGB \(\rightarrow\) L*u*v* transformation. For example, if you have a 32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will have the 0..255 value range instead of 0..1 assumed by the function. So, before calling cvtColor , you need first to scale the image down:

img *= 1./255;

If you use cvtColor with 8-bit images, the conversion will have some information lost. For many applications, this will not be noticeable but it is recommended to use 32-bit images in applications that need the full range of colors or that convert an image before an operation and then convert back.

If conversion adds the alpha channel, its value will set to the maximum of corresponding channel range: 255 for CV_8U, 65535 for CV_16U, 1 for CV_32F.

Parameters
srcinput image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision floating-point.
dstoutput image of the same size and depth as src.
codecolor space conversion code (see #ColorConversionCodes).
dstCnnumber of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.
See also
imgproc_color_conversions

◆ cvtColor() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.cvtColor ( Mat  src,
Mat  dst,
int  code 
)
static

Converts an image from one color space to another.

The function converts an input image from one color space to another. In case of a transformation to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR). Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.

The conventional ranges for R, G, and B channel values are:

  • 0 to 255 for CV_8U images
  • 0 to 65535 for CV_16U images
  • 0 to 1 for CV_32F images

In case of linear transformations, the range does not matter. But in case of a non-linear transformation, an input RGB image should be normalized to the proper value range to get the correct results, for example, for RGB \(\rightarrow\) L*u*v* transformation. For example, if you have a 32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will have the 0..255 value range instead of 0..1 assumed by the function. So, before calling cvtColor , you need first to scale the image down:

img *= 1./255;

If you use cvtColor with 8-bit images, the conversion will have some information lost. For many applications, this will not be noticeable but it is recommended to use 32-bit images in applications that need the full range of colors or that convert an image before an operation and then convert back.

If conversion adds the alpha channel, its value will set to the maximum of corresponding channel range: 255 for CV_8U, 65535 for CV_16U, 1 for CV_32F.

Parameters
srcinput image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision floating-point.
dstoutput image of the same size and depth as src.
codecolor space conversion code (see #ColorConversionCodes).
dstCnnumber of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.
See also
imgproc_color_conversions

◆ cvtColorTwoPlane()

static void OpenCVForUnity.ImgprocModule.Imgproc.cvtColorTwoPlane ( Mat  src1,
Mat  src2,
Mat  dst,
int  code 
)
static

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

This function only supports YUV420 to RGB conversion as of now.

Parameters
src18-bit image (#CV_8U) of the Y plane.
src2image containing interleaved U/V plane.
dstoutput image.
codeSpecifies the type of conversion. It can take any of the following values:

◆ demosaicing() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.demosaicing ( Mat  src,
Mat  dst,
int  code,
int  dstCn 
)
static

main function for all demosaicing processes

Parameters
srcinput image: 8-bit unsigned or 16-bit unsigned.
dstoutput image of the same size and depth as src.
codeColor space conversion code (see the description below).
dstCnnumber of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.

The function can do the following transformations:

See also
cvtColor

◆ demosaicing() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.demosaicing ( Mat  src,
Mat  dst,
int  code 
)
static

main function for all demosaicing processes

Parameters
srcinput image: 8-bit unsigned or 16-bit unsigned.
dstoutput image of the same size and depth as src.
codeColor space conversion code (see the description below).
dstCnnumber of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.

The function can do the following transformations:

See also
cvtColor

◆ dilate() [1/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.dilate ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations,
int  borderType,
Scalar  borderValue 
)
static

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for dilation; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ dilate() [2/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.dilate ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations,
int  borderType 
)
static

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for dilation; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ dilate() [3/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.dilate ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations 
)
static

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for dilation; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ dilate() [4/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.dilate ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor 
)
static

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for dilation; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ dilate() [5/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.dilate ( Mat  src,
Mat  dst,
Mat  kernel 
)
static

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for dilation; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ distanceTransform() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.distanceTransform ( Mat  src,
Mat  dst,
int  distanceType,
int  maskSize,
int  dstType 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
src8-bit, single-channel (binary) source image.
dstOutput image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src .
distanceTypeType of distance, see #DistanceTypes
maskSizeSize of the distance transform mask, see #DistanceTransformMasks. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \(3\times 3\) mask gives the same result as \(5\times 5\) or any larger aperture.
dstTypeType of output image. It can be CV_8U or CV_32F. Type CV_8U can be used only for the first variant of the function and distanceType == DIST_L1.

◆ distanceTransform() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.distanceTransform ( Mat  src,
Mat  dst,
int  distanceType,
int  maskSize 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
src8-bit, single-channel (binary) source image.
dstOutput image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src .
distanceTypeType of distance, see #DistanceTypes
maskSizeSize of the distance transform mask, see #DistanceTransformMasks. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \(3\times 3\) mask gives the same result as \(5\times 5\) or any larger aperture.
dstTypeType of output image. It can be CV_8U or CV_32F. Type CV_8U can be used only for the first variant of the function and distanceType == DIST_L1.

◆ distanceTransformWithLabels() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.distanceTransformWithLabels ( Mat  src,
Mat  dst,
Mat  labels,
int  distanceType,
int  maskSize,
int  labelType 
)
static

Calculates the distance to the closest zero pixel for each pixel of the source image.

The function cv::distanceTransform calculates the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.

When maskSize == DIST_MASK_PRECISE and distanceType == DIST_L2 , the function runs the algorithm described in [Felzenszwalb04] . This algorithm is parallelized with the TBB library.

In other cases, the algorithm [Borgefors86] is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight's move (the latest is available for a \(5\times 5\) mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as b), and all knight's moves must have the same cost (denoted as c). For the DIST_C and DIST_L1 types, the distance is calculated precisely, whereas for DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a \(5\times 5\) mask gives more accurate results). For a,b, and c, OpenCV uses the values suggested in the original paper:

  • DIST_L1: a = 1, b = 2
  • DIST_L2:
    • 3 x 3: a=0.955, b=1.3693
    • 5 x 5: a=1, b=1.4, c=2.1969
  • DIST_C: a = 1, b = 1

Typically, for a fast, coarse distance estimation DIST_L2, a \(3\times 3\) mask is used. For a more accurate distance estimation DIST_L2, a \(5\times 5\) mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.

This variant of the function does not only compute the minimum distance for each pixel \((x, y)\) but also identifies the nearest connected component consisting of zero pixels (labelType==DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==DIST_LABEL_PIXEL). Index of the component/pixel is stored in labels(x, y). When labelType==DIST_LABEL_CCOMP, the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType==DIST_LABEL_PIXEL, the function scans through the input image and marks all the zero pixels with distinct labels.

In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image. Currently, the second variant can use only the approximate distance transform algorithm, i.e. maskSize=DIST_MASK_PRECISE is not supported yet.

Parameters
src8-bit, single-channel (binary) source image.
dstOutput image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src.
labelsOutput 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src.
distanceTypeType of distance, see #DistanceTypes
maskSizeSize of the distance transform mask, see #DistanceTransformMasks. DIST_MASK_PRECISE is not supported by this variant. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \(3\times 3\) mask gives the same result as \(5\times 5\) or any larger aperture.
labelTypeType of the label array to build, see #DistanceTransformLabelTypes.

◆ distanceTransformWithLabels() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.distanceTransformWithLabels ( Mat  src,
Mat  dst,
Mat  labels,
int  distanceType,
int  maskSize 
)
static

Calculates the distance to the closest zero pixel for each pixel of the source image.

The function cv::distanceTransform calculates the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.

When maskSize == DIST_MASK_PRECISE and distanceType == DIST_L2 , the function runs the algorithm described in [Felzenszwalb04] . This algorithm is parallelized with the TBB library.

In other cases, the algorithm [Borgefors86] is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight's move (the latest is available for a \(5\times 5\) mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as b), and all knight's moves must have the same cost (denoted as c). For the DIST_C and DIST_L1 types, the distance is calculated precisely, whereas for DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a \(5\times 5\) mask gives more accurate results). For a,b, and c, OpenCV uses the values suggested in the original paper:

  • DIST_L1: a = 1, b = 2
  • DIST_L2:
    • 3 x 3: a=0.955, b=1.3693
    • 5 x 5: a=1, b=1.4, c=2.1969
  • DIST_C: a = 1, b = 1

Typically, for a fast, coarse distance estimation DIST_L2, a \(3\times 3\) mask is used. For a more accurate distance estimation DIST_L2, a \(5\times 5\) mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.

This variant of the function does not only compute the minimum distance for each pixel \((x, y)\) but also identifies the nearest connected component consisting of zero pixels (labelType==DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==DIST_LABEL_PIXEL). Index of the component/pixel is stored in labels(x, y). When labelType==DIST_LABEL_CCOMP, the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType==DIST_LABEL_PIXEL, the function scans through the input image and marks all the zero pixels with distinct labels.

In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image. Currently, the second variant can use only the approximate distance transform algorithm, i.e. maskSize=DIST_MASK_PRECISE is not supported yet.

Parameters
src8-bit, single-channel (binary) source image.
dstOutput image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src.
labelsOutput 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src.
distanceTypeType of distance, see #DistanceTypes
maskSizeSize of the distance transform mask, see #DistanceTransformMasks. DIST_MASK_PRECISE is not supported by this variant. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \(3\times 3\) mask gives the same result as \(5\times 5\) or any larger aperture.
labelTypeType of the label array to build, see #DistanceTransformLabelTypes.

◆ divSpectrums() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.divSpectrums ( Mat  a,
Mat  b,
Mat  c,
int  flags,
bool  conjB 
)
static

Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.

The function cv::divSpectrums performs the per-element division of the first array by the second array. The arrays are CCS-packed or complex matrices that are results of a real or complex Fourier transform.

Parameters
afirst input array.
bsecond input array of the same size and type as src1 .
coutput array of the same size and type as src1 .
flagsoperation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.
conjBoptional flag that conjugates the second input array before the multiplication (true) or not (false).

◆ divSpectrums() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.divSpectrums ( Mat  a,
Mat  b,
Mat  c,
int  flags 
)
static

Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.

The function cv::divSpectrums performs the per-element division of the first array by the second array. The arrays are CCS-packed or complex matrices that are results of a real or complex Fourier transform.

Parameters
afirst input array.
bsecond input array of the same size and type as src1 .
coutput array of the same size and type as src1 .
flagsoperation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.
conjBoptional flag that conjugates the second input array before the multiplication (true) or not (false).

◆ drawContours() [1/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color,
int  thickness,
int  lineType,
Mat  hierarchy,
int  maxLevel,
Point  offset 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawContours() [2/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color,
int  thickness,
int  lineType,
Mat  hierarchy,
int  maxLevel 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawContours() [3/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color,
int  thickness,
int  lineType,
Mat  hierarchy 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawContours() [4/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color,
int  thickness,
int  lineType 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawContours() [5/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color,
int  thickness 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawContours() [6/6]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawContours ( Mat  image,
List< MatOfPoint contours,
int  contourIdx,
Scalar  color 
)
static

Draws contours outlines or filled contours.

The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :

Parameters
imageDestination image.
contoursAll the input contours. Each contour is stored as a point vector.
contourIdxParameter indicating a contour to draw. If it is negative, all the contours are drawn.
colorColor of the contours.
thicknessThickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.
lineTypeLine connectivity. See #LineTypes
hierarchyOptional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).
maxLevelMaximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.
offsetOptional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.

◆ drawMarker() [1/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawMarker ( Mat  img,
Point  position,
Scalar  color,
int  markerType,
int  markerSize,
int  thickness,
int  line_type 
)
static

Draws a marker on a predefined position in an image.

The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see #MarkerTypes for more information.

Parameters
imgImage.
positionThe point where the crosshair is positioned.
colorLine color.
markerTypeThe specific type of marker you want to use, see #MarkerTypes
thicknessLine thickness.
line_typeType of the line, See #LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]

◆ drawMarker() [2/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawMarker ( Mat  img,
Point  position,
Scalar  color,
int  markerType,
int  markerSize,
int  thickness 
)
static

Draws a marker on a predefined position in an image.

The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see #MarkerTypes for more information.

Parameters
imgImage.
positionThe point where the crosshair is positioned.
colorLine color.
markerTypeThe specific type of marker you want to use, see #MarkerTypes
thicknessLine thickness.
line_typeType of the line, See #LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]

◆ drawMarker() [3/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawMarker ( Mat  img,
Point  position,
Scalar  color,
int  markerType,
int  markerSize 
)
static

Draws a marker on a predefined position in an image.

The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see #MarkerTypes for more information.

Parameters
imgImage.
positionThe point where the crosshair is positioned.
colorLine color.
markerTypeThe specific type of marker you want to use, see #MarkerTypes
thicknessLine thickness.
line_typeType of the line, See #LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]

◆ drawMarker() [4/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawMarker ( Mat  img,
Point  position,
Scalar  color,
int  markerType 
)
static

Draws a marker on a predefined position in an image.

The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see #MarkerTypes for more information.

Parameters
imgImage.
positionThe point where the crosshair is positioned.
colorLine color.
markerTypeThe specific type of marker you want to use, see #MarkerTypes
thicknessLine thickness.
line_typeType of the line, See #LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]

◆ drawMarker() [5/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.drawMarker ( Mat  img,
Point  position,
Scalar  color 
)
static

Draws a marker on a predefined position in an image.

The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see #MarkerTypes for more information.

Parameters
imgImage.
positionThe point where the crosshair is positioned.
colorLine color.
markerTypeThe specific type of marker you want to use, see #MarkerTypes
thicknessLine thickness.
line_typeType of the line, See #LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]

◆ ellipse() [1/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
Point  center,
Size  axes,
double  angle,
double  startAngle,
double  endAngle,
Scalar  color,
int  thickness,
int  lineType,
int  shift 
)
static

Draws a simple or thick elliptic arc or fills an ellipse sector.

The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses general parametric form. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly. If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360. If startAngle is greater than endAngle, they are swapped. The figure below explains the meaning of the parameters to draw the blue arc.

ellipse.svg
Parameters of Elliptic Arc
Parameters
imgImage.
centerCenter of the ellipse.
axesHalf of the size of the ellipse main axes.
angleEllipse rotation angle in degrees.
startAngleStarting angle of the elliptic arc in degrees.
endAngleEnding angle of the elliptic arc in degrees.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and values of axes.

◆ ellipse() [2/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
Point  center,
Size  axes,
double  angle,
double  startAngle,
double  endAngle,
Scalar  color,
int  thickness,
int  lineType 
)
static

Draws a simple or thick elliptic arc or fills an ellipse sector.

The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses general parametric form. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly. If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360. If startAngle is greater than endAngle, they are swapped. The figure below explains the meaning of the parameters to draw the blue arc.

ellipse.svg
Parameters of Elliptic Arc
Parameters
imgImage.
centerCenter of the ellipse.
axesHalf of the size of the ellipse main axes.
angleEllipse rotation angle in degrees.
startAngleStarting angle of the elliptic arc in degrees.
endAngleEnding angle of the elliptic arc in degrees.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and values of axes.

◆ ellipse() [3/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
Point  center,
Size  axes,
double  angle,
double  startAngle,
double  endAngle,
Scalar  color,
int  thickness 
)
static

Draws a simple or thick elliptic arc or fills an ellipse sector.

The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses general parametric form. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly. If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360. If startAngle is greater than endAngle, they are swapped. The figure below explains the meaning of the parameters to draw the blue arc.

ellipse.svg
Parameters of Elliptic Arc
Parameters
imgImage.
centerCenter of the ellipse.
axesHalf of the size of the ellipse main axes.
angleEllipse rotation angle in degrees.
startAngleStarting angle of the elliptic arc in degrees.
endAngleEnding angle of the elliptic arc in degrees.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and values of axes.

◆ ellipse() [4/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
Point  center,
Size  axes,
double  angle,
double  startAngle,
double  endAngle,
Scalar  color 
)
static

Draws a simple or thick elliptic arc or fills an ellipse sector.

The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses general parametric form. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly. If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360. If startAngle is greater than endAngle, they are swapped. The figure below explains the meaning of the parameters to draw the blue arc.

ellipse.svg
Parameters of Elliptic Arc
Parameters
imgImage.
centerCenter of the ellipse.
axesHalf of the size of the ellipse main axes.
angleEllipse rotation angle in degrees.
startAngleStarting angle of the elliptic arc in degrees.
endAngleEnding angle of the elliptic arc in degrees.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes
shiftNumber of fractional bits in the coordinates of the center and values of axes.

◆ ellipse() [5/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
RotatedRect  box,
Scalar  color,
int  thickness,
int  lineType 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imgImage.
boxAlternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes

◆ ellipse() [6/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
RotatedRect  box,
Scalar  color,
int  thickness 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imgImage.
boxAlternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes

◆ ellipse() [7/7]

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse ( Mat  img,
RotatedRect  box,
Scalar  color 
)
static

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters
imgImage.
boxAlternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.
colorEllipse color.
thicknessThickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineTypeType of the ellipse boundary. See #LineTypes

◆ ellipse2Poly()

static void OpenCVForUnity.ImgprocModule.Imgproc.ellipse2Poly ( Point  center,
Size  axes,
int  angle,
int  arcStart,
int  arcEnd,
int  delta,
MatOfPoint  pts 
)
static

Approximates an elliptic arc with a polyline.

The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by ellipse. If arcStart is greater than arcEnd, they are swapped.

Parameters
centerCenter of the arc.
axesHalf of the size of the ellipse main axes. See ellipse for details.
angleRotation angle of the ellipse in degrees. See ellipse for details.
arcStartStarting angle of the elliptic arc in degrees.
arcEndEnding angle of the elliptic arc in degrees.
deltaAngle between the subsequent polyline vertices. It defines the approximation accuracy.
ptsOutput vector of polyline vertices.

◆ EMD() [1/3]

static float OpenCVForUnity.ImgprocModule.Imgproc.EMD ( Mat  signature1,
Mat  signature2,
int  distType,
Mat  cost,
Mat  flow 
)
static

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

The function computes the earth mover distance and/or a lower boundary of the distance between the two weighted point configurations. One of the applications described in [RubnerSept98], [Rubner2000] is multi-dimensional histogram comparison for image retrieval. EMD is a transportation problem that is solved using some modification of a simplex algorithm, thus the complexity is exponential in the worst case, though, on average it is much faster. In the case of a real metric the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used to determine roughly whether the two signatures are far enough so that they cannot relate to the same object.

Parameters
signature1First signature, a \(\texttt{size1}\times \texttt{dims}+1\) floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used. The weights must be non-negative and have at least one non-zero value.
signature2Second signature of the same format as signature1 , though the number of rows may be different. The total weights may be different. In this case an extra "dummy" point is added to either signature1 or signature2. The weights must be non-negative and have at least one non-zero value.
distTypeUsed metric. See #DistanceTypes.
costUser-defined \(\texttt{size1}\times \texttt{size2}\) cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
lowerBoundOptional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (the signature matrices have a single column). You must** initialize *lowerBound . If the calculated distance between mass centers is greater or equal to *lowerBound (it means that the signatures are far enough), the function does not calculate EMD. In any case *lowerBound is set to the calculated distance between mass centers on return. Thus, if you want to calculate both distance between mass centers and EMD, *lowerBound should be set to 0.
flowResultant \(\texttt{size1} \times \texttt{size2}\) flow matrix: \(\texttt{flow}_{i,j}\) is a flow from \(i\) -th point of signature1 to \(j\) -th point of signature2 .

◆ EMD() [2/3]

static float OpenCVForUnity.ImgprocModule.Imgproc.EMD ( Mat  signature1,
Mat  signature2,
int  distType,
Mat  cost 
)
static

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

The function computes the earth mover distance and/or a lower boundary of the distance between the two weighted point configurations. One of the applications described in [RubnerSept98], [Rubner2000] is multi-dimensional histogram comparison for image retrieval. EMD is a transportation problem that is solved using some modification of a simplex algorithm, thus the complexity is exponential in the worst case, though, on average it is much faster. In the case of a real metric the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used to determine roughly whether the two signatures are far enough so that they cannot relate to the same object.

Parameters
signature1First signature, a \(\texttt{size1}\times \texttt{dims}+1\) floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used. The weights must be non-negative and have at least one non-zero value.
signature2Second signature of the same format as signature1 , though the number of rows may be different. The total weights may be different. In this case an extra "dummy" point is added to either signature1 or signature2. The weights must be non-negative and have at least one non-zero value.
distTypeUsed metric. See #DistanceTypes.
costUser-defined \(\texttt{size1}\times \texttt{size2}\) cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
lowerBoundOptional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (the signature matrices have a single column). You must** initialize *lowerBound . If the calculated distance between mass centers is greater or equal to *lowerBound (it means that the signatures are far enough), the function does not calculate EMD. In any case *lowerBound is set to the calculated distance between mass centers on return. Thus, if you want to calculate both distance between mass centers and EMD, *lowerBound should be set to 0.
flowResultant \(\texttt{size1} \times \texttt{size2}\) flow matrix: \(\texttt{flow}_{i,j}\) is a flow from \(i\) -th point of signature1 to \(j\) -th point of signature2 .

◆ EMD() [3/3]

static float OpenCVForUnity.ImgprocModule.Imgproc.EMD ( Mat  signature1,
Mat  signature2,
int  distType 
)
static

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

The function computes the earth mover distance and/or a lower boundary of the distance between the two weighted point configurations. One of the applications described in [RubnerSept98], [Rubner2000] is multi-dimensional histogram comparison for image retrieval. EMD is a transportation problem that is solved using some modification of a simplex algorithm, thus the complexity is exponential in the worst case, though, on average it is much faster. In the case of a real metric the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used to determine roughly whether the two signatures are far enough so that they cannot relate to the same object.

Parameters
signature1First signature, a \(\texttt{size1}\times \texttt{dims}+1\) floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used. The weights must be non-negative and have at least one non-zero value.
signature2Second signature of the same format as signature1 , though the number of rows may be different. The total weights may be different. In this case an extra "dummy" point is added to either signature1 or signature2. The weights must be non-negative and have at least one non-zero value.
distTypeUsed metric. See #DistanceTypes.
costUser-defined \(\texttt{size1}\times \texttt{size2}\) cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
lowerBoundOptional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (the signature matrices have a single column). You must** initialize *lowerBound . If the calculated distance between mass centers is greater or equal to *lowerBound (it means that the signatures are far enough), the function does not calculate EMD. In any case *lowerBound is set to the calculated distance between mass centers on return. Thus, if you want to calculate both distance between mass centers and EMD, *lowerBound should be set to 0.
flowResultant \(\texttt{size1} \times \texttt{size2}\) flow matrix: \(\texttt{flow}_{i,j}\) is a flow from \(i\) -th point of signature1 to \(j\) -th point of signature2 .

◆ equalizeHist()

static void OpenCVForUnity.ImgprocModule.Imgproc.equalizeHist ( Mat  src,
Mat  dst 
)
static

Equalizes the histogram of a grayscale image.

The function equalizes the histogram of the input image using the following algorithm:

  • Calculate the histogram \(H\) for src .
  • Normalize the histogram so that the sum of histogram bins is 255.
  • Compute the integral of the histogram:

    \[H'_i = \sum _{0 \le j < i} H(j)\]

  • Transform the image using \(H'\) as a look-up table: \(\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\)

The algorithm normalizes the brightness and increases the contrast of the image.

Parameters
srcSource 8-bit single channel image.
dstDestination image of the same size and type as src .

◆ erode() [1/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.erode ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations,
int  borderType,
Scalar  borderValue 
)
static

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
borderValueborder value in case of a constant border
See also
dilate, morphologyEx, getStructuringElement

◆ erode() [2/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.erode ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations,
int  borderType 
)
static

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
borderValueborder value in case of a constant border
See also
dilate, morphologyEx, getStructuringElement

◆ erode() [3/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.erode ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor,
int  iterations 
)
static

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
borderValueborder value in case of a constant border
See also
dilate, morphologyEx, getStructuringElement

◆ erode() [4/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.erode ( Mat  src,
Mat  dst,
Mat  kernel,
Point  anchor 
)
static

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
borderValueborder value in case of a constant border
See also
dilate, morphologyEx, getStructuringElement

◆ erode() [5/5]

static void OpenCVForUnity.ImgprocModule.Imgproc.erode ( Mat  src,
Mat  dst,
Mat  kernel 
)
static

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters
srcinput image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dstoutput image of the same size and type as src.
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
borderValueborder value in case of a constant border
See also
dilate, morphologyEx, getStructuringElement

◆ fillConvexPoly() [1/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillConvexPoly ( Mat  img,
MatOfPoint  points,
Scalar  color,
int  lineType,
int  shift 
)
static

Fills a convex polygon.

The function cv::fillConvexPoly draws a filled convex polygon. This function is much faster than the function fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).

Parameters
imgImage.
pointsPolygon vertices.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.

◆ fillConvexPoly() [2/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillConvexPoly ( Mat  img,
MatOfPoint  points,
Scalar  color,
int  lineType 
)
static

Fills a convex polygon.

The function cv::fillConvexPoly draws a filled convex polygon. This function is much faster than the function fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).

Parameters
imgImage.
pointsPolygon vertices.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.

◆ fillConvexPoly() [3/3]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillConvexPoly ( Mat  img,
MatOfPoint  points,
Scalar  color 
)
static

Fills a convex polygon.

The function cv::fillConvexPoly draws a filled convex polygon. This function is much faster than the function fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).

Parameters
imgImage.
pointsPolygon vertices.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.

◆ fillPoly() [1/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillPoly ( Mat  img,
List< MatOfPoint pts,
Scalar  color,
int  lineType,
int  shift,
Point  offset 
)
static

Fills the area bounded by one or more polygons.

The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.

Parameters
imgImage.
ptsArray of polygons where each polygon is represented as an array of points.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.
offsetOptional offset of all points of the contours.

◆ fillPoly() [2/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillPoly ( Mat  img,
List< MatOfPoint pts,
Scalar  color,
int  lineType,
int  shift 
)
static

Fills the area bounded by one or more polygons.

The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.

Parameters
imgImage.
ptsArray of polygons where each polygon is represented as an array of points.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.
offsetOptional offset of all points of the contours.

◆ fillPoly() [3/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillPoly ( Mat  img,
List< MatOfPoint pts,
Scalar  color,
int  lineType 
)
static

Fills the area bounded by one or more polygons.

The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.

Parameters
imgImage.
ptsArray of polygons where each polygon is represented as an array of points.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.
offsetOptional offset of all points of the contours.

◆ fillPoly() [4/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.fillPoly ( Mat  img,
List< MatOfPoint pts,
Scalar  color 
)
static

Fills the area bounded by one or more polygons.

The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.

Parameters
imgImage.
ptsArray of polygons where each polygon is represented as an array of points.
colorPolygon color.
lineTypeType of the polygon boundaries. See #LineTypes
shiftNumber of fractional bits in the vertex coordinates.
offsetOptional offset of all points of the contours.

◆ filter2D() [1/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.filter2D ( Mat  src,
Mat  dst,
int  ddepth,
Mat  kernel,
Point  anchor,
double  delta,
int  borderType 
)
static

Convolves an image with the kernel.

The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.

The function does actually compute correlation, not the convolution:

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using #flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).

The function uses the DFT-based algorithm in case of sufficiently large kernels (~11 x 11 or larger) and the direct algorithm for small kernels.

Parameters
srcinput image.
dstoutput image of the same size and the same number of channels as src.
ddepthdesired depth of the destination image, see combinations
kernelconvolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchoranchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
deltaoptional value added to the filtered pixels before storing them in dst.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
See also
sepFilter2D, dft, matchTemplate

◆ filter2D() [2/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.filter2D ( Mat  src,
Mat  dst,
int  ddepth,
Mat  kernel,
Point  anchor,
double  delta 
)
static

Convolves an image with the kernel.

The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.

The function does actually compute correlation, not the convolution:

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using #flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).

The function uses the DFT-based algorithm in case of sufficiently large kernels (~11 x 11 or larger) and the direct algorithm for small kernels.

Parameters
srcinput image.
dstoutput image of the same size and the same number of channels as src.
ddepthdesired depth of the destination image, see combinations
kernelconvolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchoranchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
deltaoptional value added to the filtered pixels before storing them in dst.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
See also
sepFilter2D, dft, matchTemplate

◆ filter2D() [3/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.filter2D ( Mat  src,
Mat  dst,
int  ddepth,
Mat  kernel,
Point  anchor 
)
static

Convolves an image with the kernel.

The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.

The function does actually compute correlation, not the convolution:

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using #flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).

The function uses the DFT-based algorithm in case of sufficiently large kernels (~11 x 11 or larger) and the direct algorithm for small kernels.

Parameters
srcinput image.
dstoutput image of the same size and the same number of channels as src.
ddepthdesired depth of the destination image, see combinations
kernelconvolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchoranchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
deltaoptional value added to the filtered pixels before storing them in dst.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
See also
sepFilter2D, dft, matchTemplate

◆ filter2D() [4/4]

static void OpenCVForUnity.ImgprocModule.Imgproc.filter2D ( Mat  src,
Mat  dst,
int  ddepth,
Mat  kernel 
)
static

Convolves an image with the kernel.

The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.

The function does actually compute correlation, not the convolution:

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using #flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).

The function uses the DFT-based algorithm in case of sufficiently large kernels (~11 x 11 or larger) and the direct algorithm for small kernels.

Parameters
srcinput image.
dstoutput image of the same size and the same number of channels as src.
ddepthdesired depth of the destination image, see combinations
kernelconvolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchoranchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
deltaoptional value added to the filtered pixels before storing them in dst.
borderTypepixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
See also
sepFilter2D, dft, matchTemplate

◆ findContours() [1/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.findContours ( Mat  image,
List< MatOfPoint contours,
Mat  hierarchy,
int  mode,
int  method,
Point  offset 
)
static

Finds contours in a binary image.

The function retrieves contours from the binary image using the algorithm [Suzuki85] . The contours are a useful tool for shape analysis and object detection and recognition. See squares.cpp in the OpenCV sample directory.

Note
Since opencv 3.2 source image is not modified by this function.
Parameters
imageSource, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, threshold , adaptiveThreshold, Canny, and others to create a binary image out of a grayscale or color one. If mode equals to RETR_CCOMP or RETR_FLOODFILL, the input can also be a 32-bit integer image of labels (CV_32SC1).
contoursDetected contours. Each contour is stored as a vector of points (e.g. std::vector<std::vector<cv::Point> >).
hierarchyOptional output vector (e.g. std::vector<cv::Vec4i>), containing information about the image topology. It has as many elements as the number of contours. For each i-th contour contours[i], the elements hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are set to 0-based indices in contours of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.
Note
In Python, hierarchy is nested inside a top level array. Use hierarchy[0][i] to access hierarchical elements of i-th contour.
Parameters
modeContour retrieval mode, see #RetrievalModes
methodContour approximation method, see #ContourApproximationModes
offsetOptional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

◆ findContours() [2/2]

static void OpenCVForUnity.ImgprocModule.Imgproc.findContours ( Mat  image,
List< MatOfPoint contours,
Mat  hierarchy,
int  mode,
int  method 
)
static

Finds contours in a binary image.

The function retrieves contours from the binary image using the algorithm [Suzuki85] . The contours are a useful tool for shape analysis and object detection and recognition. See squares.cpp in the OpenCV sample directory.

Note
Since opencv 3.2 source image is not modified by this function.
Parameters
imageSource, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, threshold , adaptiveThreshold, Canny, and others to create a binary image out of a grayscale or color one. If mode equals to RETR_CCOMP or RETR_FLOODFILL, the input can also be a 32-bit integer image of labels (CV_32SC1).
contoursDetected contours. Each contour is stored as a vector of points (e.g. std::vector<std::vector<cv::Point> >).
hierarchyOptional output vector (e.g. std::vector<cv::Vec4i>), containing information about the image topology. It has as many elements as the number of contours. For each i-th contour contours[i], the elements hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are set to 0-based indices in contours of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.
Note
In Python, hierarchy is nested inside a top level array. Use hierarchy[0][i] to access hierarchical elements of i-th contour.
Parameters
modeContour retrieval mode, see #RetrievalModes
methodContour approximation method, see #ContourApproximationModes
offsetOptional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

◆ fitEllipse()

static RotatedRect OpenCVForUnity.ImgprocModule.Imgproc.fitEllipse ( MatOfPoint2f  points)
static

Fits an ellipse around a set of 2D points.

The function calculates the ellipse that fits (in a least-squares sense) a set of 2D points best of all. It returns the rotated rectangle in which the ellipse is inscribed. The first algorithm described by [Fitzgibbon95] is used. Developer should keep in mind that it is possible that the returned ellipse/rotatedRect data contains negative indices, due to the data points being close to the border of the containing Mat element.

Parameters
pointsInput 2D point set, stored in std::vector<> or Mat

◆ fitEllipseAMS()

static RotatedRect OpenCVForUnity.ImgprocModule.Imgproc.fitEllipseAMS ( Mat  points)
static

Fits an ellipse around a set of 2D points.

The function calculates the ellipse that fits a set of 2D points. It returns the rotated rectangle in which the ellipse is inscribed. The Approximate Mean Square (AMS) proposed by [Taubin1991] is used.

For an ellipse, this basis set is \( \chi= \left(x^2, x y, y^2, x, y, 1\right) \), which is a set of six free coefficients \( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \). However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths \( (a,b) \), the position \( (x_0,y_0) \), and the orientation \( \theta \). This is because the basis set includes lines, quadratics, parabolic and hyperbolic functions as well as elliptical functions as possible fits. If the fit is found to be a parabolic or hyperbolic function then the standard fitEllipse method is used. The AMS method restricts the fit to parabolic, hyperbolic and elliptical curves by imposing the condition that \( A^T ( D_x^T D_x + D_y^T D_y) A = 1 \) where the matrices \( Dx \) and \( Dy \) are the partial derivatives of the design matrix \( D \) with respect to x and y. The matrices are formed row by row applying the following to each of the points in the set:

\begin{align*} D(i,:)&=\left\{x_i^2, x_i y_i, y_i^2, x_i, y_i, 1\right\} & D_x(i,:)&=\left\{2 x_i,y_i,0,1,0,0\right\} & D_y(i,:)&=\left\{0,x_i,2 y_i,0,1,0\right\} \end{align*}

The AMS method minimizes the cost function

\begin{equation*} \epsilon ^2=\frac{ A^T D^T D A }{ A^T (D_x^T D_x + D_y^T D_y) A^T } \end{equation*}

The minimum cost is found by solving the generalized eigenvalue problem.

\begin{equation*} D^T D A = \lambda \left( D_x^T D_x + D_y^T D_y\right) A \end{equation*}

Parameters
pointsInput 2D point set, stored in std::vector<> or Mat

◆ fitEllipseDirect()

static RotatedRect OpenCVForUnity.ImgprocModule.Imgproc.fitEllipseDirect ( Mat  points)
static

Fits an ellipse around a set of 2D points.

The function calculates the ellipse that fits a set of 2D points. It returns the rotated rectangle in which the ellipse is inscribed. The Direct least square (Direct) method by [Fitzgibbon1999] is used.

For an ellipse, this basis set is \( \chi= \left(x^2, x y, y^2, x, y, 1\right) \), which is a set of six free coefficients \( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \). However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths \( (a,b) \), the position \( (x_0,y_0) \), and the orientation \( \theta \). This is because the basis set includes lines, quadratics, parabolic and hyperbolic functions as well as elliptical functions as possible fits. The Direct method confines the fit to ellipses by ensuring that \( 4 A_{xx} A_{yy}- A_{xy}^2 > 0 \). The condition imposed is that \( 4 A_{xx} A_{yy}- A_{xy}^2=1 \) which satisfies the inequality and as the coefficients can be arbitrarily scaled is not overly restrictive.

\begin{equation*} \epsilon ^2= A^T D^T D A \quad \text{with} \quad A^T C A =1 \quad \text{and} \quad C=\left(\begin{matrix} 0 & 0 & 2 & 0 & 0 & 0 \\ 0 & -1 & 0 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix} \right) \end{equation*}

The minimum cost is found by solving the generalized eigenvalue problem.

\begin{equation*} D^T D A = \lambda \left( C\right) A \end{equation*}

The system produces only one positive eigenvalue \( \lambda\) which is chosen as the solution with its eigenvector \(\mathbf{u}\). These are used to find the coefficients

\begin{equation*} A = \sqrt{\frac{1}{\mathbf{u}^T C \mathbf{u}}} \mathbf{u} \end{equation*}

The scaling factor guarantees that \(A^T C A =1\).

Parameters
pointsInput 2D point set, stored in std::vector<> or Mat

◆ fitLine()

static void OpenCVForUnity.ImgprocModule.Imgproc.fitLine ( Mat  points,
Mat  line,
int  distType,
double  param,
double  reps,
double  aeps 
)
static

Fits a line to a 2D or 3D point set.

The function fitLine fits a line to a 2D or 3D point set by minimizing \(\sum_i \rho(r_i)\) where \(r_i\) is a distance between the \(i^{th}\) point, the line and \(\rho(r)\) is a distance function, one of the following:

  • DIST_L2

    \[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\]

  • DIST_L1

    \[\rho (r) = r\]

  • DIST_L12

    \[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\]

  • DIST_FAIR

    \[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\]

  • DIST_WELSCH

    \[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\]

  • DIST_HUBER

    \[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\]

The algorithm is based on the M-estimator ( <http://en.wikipedia.org/wiki/M-estimator&gt; ) technique that iteratively fits the line using the weighted least-squares algorithm. After each iteration the weights \(w_i\) are adjusted to be inversely proportional to \(\rho(r_i)\) .

Parameters
pointsInput vector of 2D or 3D points, stored in std::vector<> or Mat.
lineOutput line parameters. In case of 2D fitting, it should be a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line. In case of 3D fitting, it should be a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0), where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on the line.
distTypeDistance used by the M-estimator, see #DistanceTypes
paramNumerical parameter ( C ) for some types of distances. If it is 0, an optimal value is chosen.
repsSufficient accuracy for the radius (distance between the coordinate origin and the line).
aepsSufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.

◆ floodFill() [1/5]

static int OpenCVForUnity.ImgprocModule.Imgproc.floodFill ( Mat  image,
Mat  mask,
Point  seedPoint,
Scalar  newVal,
Rect  rect,
Scalar  loDiff,
Scalar  upDiff,
int  flags 
)
static

Fills a connected component with the given color.

The function cv::floodFill fills a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The pixel at \((x,y)\) is considered to belong to the repainted domain if:

  • in case of a grayscale image and floating range

    \[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\]

  • in case of a grayscale image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\]

  • in case of a color image and floating range

    \[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\]

  • in case of a color image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\]

where \(src(x',y')\) is the value of one of pixel neighbors that is already known to belong to the component. That is, to be added to the connected component, a color/brightness of the pixel should be close enough to:

  • Color/brightness of one of its neighbors that already belong to the connected component in case of a floating range.
  • Color/brightness of the seed point in case of a fixed range.

Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on.

Parameters
imageInput/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below.
maskOperation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. If an empty Mat is passed it will be created automatically. Since this is both an input and output parameter, you must take responsibility of initializing it. Flood-filling cannot go across non-zero pixels in the input mask. For example, an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the mask corresponding to filled pixels in the image are set to 1 or to the specified value in flags as described below. Additionally, the function fills the border of the mask with ones to simplify internal processing. It is therefore possible to use the same mask in multiple calls to the function to make sure the filled areas do not overlap.
seedPointStarting point.
newValNew value of the repainted domain pixels.
loDiffMaximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
upDiffMaximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
rectOptional output parameter set by the function to the minimum bounding rectangle of the repainted domain.
flagsOperation flags. The first 8 bits contain a connectivity value. The default value of 4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner) will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the default value is 1). For example, 4 | ( 255 << 8 ) will consider 4 nearest neighbours and fill the mask with a value of 255. The following additional options occupy higher bits and therefore may be further combined with the connectivity and mask fill values using bit-wise or (|), see #FloodFillFlags.
Note
Since the mask is larger than the filled image, a pixel \((x, y)\) in image corresponds to the pixel \((x+1, y+1)\) in the mask .
See also
findContours

◆ floodFill() [2/5]

static int OpenCVForUnity.ImgprocModule.Imgproc.floodFill ( Mat  image,
Mat  mask,
Point  seedPoint,
Scalar  newVal,
Rect  rect,
Scalar  loDiff,
Scalar  upDiff 
)
static

Fills a connected component with the given color.

The function cv::floodFill fills a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The pixel at \((x,y)\) is considered to belong to the repainted domain if:

  • in case of a grayscale image and floating range

    \[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\]

  • in case of a grayscale image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\]

  • in case of a color image and floating range

    \[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\]

  • in case of a color image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\]

where \(src(x',y')\) is the value of one of pixel neighbors that is already known to belong to the component. That is, to be added to the connected component, a color/brightness of the pixel should be close enough to:

  • Color/brightness of one of its neighbors that already belong to the connected component in case of a floating range.
  • Color/brightness of the seed point in case of a fixed range.

Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on.

Parameters
imageInput/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below.
maskOperation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. If an empty Mat is passed it will be created automatically. Since this is both an input and output parameter, you must take responsibility of initializing it. Flood-filling cannot go across non-zero pixels in the input mask. For example, an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the mask corresponding to filled pixels in the image are set to 1 or to the specified value in flags as described below. Additionally, the function fills the border of the mask with ones to simplify internal processing. It is therefore possible to use the same mask in multiple calls to the function to make sure the filled areas do not overlap.
seedPointStarting point.
newValNew value of the repainted domain pixels.
loDiffMaximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
upDiffMaximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
rectOptional output parameter set by the function to the minimum bounding rectangle of the repainted domain.
flagsOperation flags. The first 8 bits contain a connectivity value. The default value of 4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner) will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the default value is 1). For example, 4 | ( 255 << 8 ) will consider 4 nearest neighbours and fill the mask with a value of 255. The following additional options occupy higher bits and therefore may be further combined with the connectivity and mask fill values using bit-wise or (|), see #FloodFillFlags.
Note
Since the mask is larger than the filled image, a pixel \((x, y)\) in image corresponds to the pixel \((x+1, y+1)\) in the mask .
See also
findContours

◆ floodFill() [3/5]

static int OpenCVForUnity.ImgprocModule.Imgproc.floodFill ( Mat  image,
Mat  mask,
Point  seedPoint,
Scalar  newVal,
Rect  rect,
Scalar  loDiff 
)
static

Fills a connected component with the given color.

The function cv::floodFill fills a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The pixel at \((x,y)\) is considered to belong to the repainted domain if:

  • in case of a grayscale image and floating range

    \[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\]

  • in case of a grayscale image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\]

  • in case of a color image and floating range

    \[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\]

  • in case of a color image and fixed range

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\]

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\]

    and

    \[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff