@property (class, readonly) int CV_GAUSSIAN_5x5

class var CV_GAUSSIAN_5x5: Int32 { get }

@property (class, readonly) int CV_SCHARR

class var CV_SCHARR: Int32 { get }

@property (class, readonly) int CV_MAX_SOBEL_KSIZE

class var CV_MAX_SOBEL_KSIZE: Int32 { get }

@property (class, readonly) int CV_RGBA2mRGBA

class var CV_RGBA2mRGBA: Int32 { get }

@property (class, readonly) int CV_mRGBA2RGBA

class var CV_mRGBA2RGBA: Int32 { get }

@property (class, readonly) int CV_WARP_FILL_OUTLIERS

class var CV_WARP_FILL_OUTLIERS: Int32 { get }

@property (class, readonly) int CV_WARP_INVERSE_MAP

class var CV_WARP_INVERSE_MAP: Int32 { get }

@property (class, readonly) int CV_CHAIN_CODE

class var CV_CHAIN_CODE: Int32 { get }

@property (class, readonly) int CV_LINK_RUNS

class var CV_LINK_RUNS: Int32 { get }

@property (class, readonly) int CV_POLY_APPROX_DP

class var CV_POLY_APPROX_DP: Int32 { get }

@property (class, readonly) int CV_CLOCKWISE

class var CV_CLOCKWISE: Int32 { get }

@property (class, readonly) int CV_COUNTER_CLOCKWISE

class var CV_COUNTER_CLOCKWISE: Int32 { get }

@property (class, readonly) int CV_CANNY_L2_GRADIENT

class var CV_CANNY_L2_GRADIENT: Int32 { get }

+ (Mat*)getAffineTransform:(NSArray<Point2f*>*)src dst:(NSArray<Point2f*>*)dst NS_SWIFT_NAME(getAffineTransform(src:dst:));

class func getAffineTransform(src: [Point2f], dst: [Point2f]) -> Mat

Returns Gabor filter coefficients.

For more details about gabor filter equations and parameters, see: Gabor Filter.

+ (nonnull Mat *)getGaborKernel:(nonnull Size2i *)ksize
                          sigma:(double)sigma
                          theta:(double)theta
                          lambd:(double)lambd
                          gamma:(double)gamma
                            psi:(double)psi
                          ktype:(int)ktype;

class func getGaborKernel(ksize: Size2i, sigma: Double, theta: Double, lambd: Double, gamma: Double, psi: Double, ktype: Int32) -> Mat

Returns Gabor filter coefficients.

For more details about gabor filter equations and parameters, see: Gabor Filter.

+ (nonnull Mat *)getGaborKernel:(nonnull Size2i *)ksize
                          sigma:(double)sigma
                          theta:(double)theta
                          lambd:(double)lambd
                          gamma:(double)gamma
                            psi:(double)psi;

class func getGaborKernel(ksize: Size2i, sigma: Double, theta: Double, lambd: Double, gamma: Double, psi: Double) -> Mat

Returns Gabor filter coefficients.

For more details about gabor filter equations and parameters, see: Gabor Filter.

+ (nonnull Mat *)getGaborKernel:(nonnull Size2i *)ksize
                          sigma:(double)sigma
                          theta:(double)theta
                          lambd:(double)lambd
                          gamma:(double)gamma;

class func getGaborKernel(ksize: Size2i, sigma: Double, theta: Double, lambd: Double, gamma: Double) -> Mat

Returns Gaussian filter coefficients.

The function computes and returns the

matrix of Gaussian filter coefficients:

where

and is the scale factor chosen so that .

Two of such generated kernels can be passed to sepFilter2D. Those functions automatically recognize smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and handle them accordingly. You may also use the higher-level GaussianBlur.

+ (nonnull Mat *)getGaussianKernel:(int)ksize
                             sigma:(double)sigma
                             ktype:(int)ktype;

class func getGaussianKernel(ksize: Int32, sigma: Double, ktype: Int32) -> Mat

Returns Gaussian filter coefficients.

The function computes and returns the

matrix of Gaussian filter coefficients:

where

and is the scale factor chosen so that .

Two of such generated kernels can be passed to sepFilter2D. Those functions automatically recognize smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and handle them accordingly. You may also use the higher-level GaussianBlur.

+ (nonnull Mat *)getGaussianKernel:(int)ksize sigma:(double)sigma;

class func getGaussianKernel(ksize: Int32, sigma: Double) -> Mat

Calculates a perspective transform from four pairs of the corresponding points.

The function calculates the

matrix of a perspective transform so that:

where

+ (nonnull Mat *)getPerspectiveTransform:(nonnull Mat *)src
                                     dst:(nonnull Mat *)dst
                             solveMethod:(int)solveMethod;

class func getPerspectiveTransform(src: Mat, dst: Mat, solveMethod: Int32) -> Mat

Calculates a perspective transform from four pairs of the corresponding points.

The function calculates the

matrix of a perspective transform so that:

where

+ (nonnull Mat *)getPerspectiveTransform:(nonnull Mat *)src
                                     dst:(nonnull Mat *)dst;

class func getPerspectiveTransform(src: Mat, dst: Mat) -> Mat

Calculates an affine matrix of 2D rotation.

The function calculates the following matrix:

where

The transformation maps the rotation center to itself. If this is not the target, adjust the shift.

+ (nonnull Mat *)getRotationMatrix2D:(nonnull Point2f *)center
                               angle:(double)angle
                               scale:(double)scale;

class func getRotationMatrix2D(center: Point2f, angle: Double, scale: Double) -> Mat

Returns a structuring element of the specified size and shape for morphological operations.

The function constructs and returns the structuring element that can be further passed to #erode, #dilate or #morphologyEx. But you can also construct an arbitrary binary mask yourself and use it as the structuring element.

+ (nonnull Mat *)getStructuringElement:(MorphShapes)shape
                                 ksize:(nonnull Size2i *)ksize
                                anchor:(nonnull Point2i *)anchor;

class func getStructuringElement(shape: MorphShapes, ksize: Size2i, anchor: Point2i) -> Mat

Returns a structuring element of the specified size and shape for morphological operations.

The function constructs and returns the structuring element that can be further passed to #erode, #dilate or #morphologyEx. But you can also construct an arbitrary binary mask yourself and use it as the structuring element.

+ (nonnull Mat *)getStructuringElement:(MorphShapes)shape
                                 ksize:(nonnull Size2i *)ksize;

class func getStructuringElement(shape: MorphShapes, ksize: Size2i) -> Mat

Calculates all of the moments up to the third order of a polygon or rasterized shape.

The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The results are returned in the structure cv::Moments.

+ (nonnull Moments *)moments:(nonnull Mat *)array binaryImage:(BOOL)binaryImage;

class func moments(array: Mat, binaryImage: Bool) -> Moments

Calculates all of the moments up to the third order of a polygon or rasterized shape.

The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The results are returned in the structure cv::Moments.

+ (nonnull Moments *)moments:(nonnull Mat *)array;

class func moments(array: Mat) -> Moments

The function is used to detect translational shifts that occur between two images.

The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation. For more information please see http://en.wikipedia.org/wiki/Phase_correlation

Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.

The function performs the following equations:

• First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function) to each image to remove possible edge effects. This window is cached until the array size changes to speed up processing time.
• Next it computes the forward DFTs of each source array:
  \mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}
  where
  \mathcal{F}
  is the forward DFT.
• It then computes the cross-power spectrum of each frequency domain array:
  R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}
• Next the cross-correlation is converted back into the time domain via the inverse DFT:
  r = \mathcal{F}^{-1}\{R\}
• Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to achieve sub-pixel accuracy.
  (\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}

• If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5 centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single peak) and will be smaller when there are multiple peaks.

+ (nonnull Point2d *)phaseCorrelate:(nonnull Mat *)src1
                               src2:(nonnull Mat *)src2
                             window:(nonnull Mat *)window
                           response:(nonnull double *)response;

class func phaseCorrelate(src1: Mat, src2: Mat, window: Mat, response: UnsafeMutablePointer<Double>) -> Point2d

The function is used to detect translational shifts that occur between two images.

The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation. For more information please see http://en.wikipedia.org/wiki/Phase_correlation

Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.

The function performs the following equations:

• First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function) to each image to remove possible edge effects. This window is cached until the array size changes to speed up processing time.
• Next it computes the forward DFTs of each source array:
  \mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}
  where
  \mathcal{F}
  is the forward DFT.
• It then computes the cross-power spectrum of each frequency domain array:
  R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}
• Next the cross-correlation is converted back into the time domain via the inverse DFT:
  r = \mathcal{F}^{-1}\{R\}
• Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to achieve sub-pixel accuracy.
  (\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}

• If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5 centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single peak) and will be smaller when there are multiple peaks.

+ (nonnull Point2d *)phaseCorrelate:(nonnull Mat *)src1
                               src2:(nonnull Mat *)src2
                             window:(nonnull Mat *)window;

class func phaseCorrelate(src1: Mat, src2: Mat, window: Mat) -> Point2d

The function is used to detect translational shifts that occur between two images.

The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation. For more information please see http://en.wikipedia.org/wiki/Phase_correlation

Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.

The function performs the following equations:

• First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function) to each image to remove possible edge effects. This window is cached until the array size changes to speed up processing time.
• Next it computes the forward DFTs of each source array:
  \mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}
  where
  \mathcal{F}
  is the forward DFT.
• It then computes the cross-power spectrum of each frequency domain array:
  R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}
• Next the cross-correlation is converted back into the time domain via the inverse DFT:
  r = \mathcal{F}^{-1}\{R\}
• Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to achieve sub-pixel accuracy.
  (\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}

• If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5 centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single peak) and will be smaller when there are multiple peaks.

+ (nonnull Point2d *)phaseCorrelate:(nonnull Mat *)src1
                               src2:(nonnull Mat *)src2;

class func phaseCorrelate(src1: Mat, src2: Mat) -> Point2d

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

+ (nonnull CLAHE *)createCLAHE:(double)clipLimit
                  tileGridSize:(nonnull Size2i *)tileGridSize;

class func createCLAHE(clipLimit: Double, tileGridSize: Size2i) -> CLAHE

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

+ (nonnull CLAHE *)createCLAHE:(double)clipLimit;

class func createCLAHE(clipLimit: Double) -> CLAHE

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

equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.

+ (nonnull CLAHE *)createCLAHE;

class func createCLAHE() -> CLAHE

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

+ (nonnull GeneralizedHoughBallard *)createGeneralizedHoughBallard;

class func createGeneralizedHoughBallard() -> GeneralizedHoughBallard

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

+ (nonnull GeneralizedHoughGuil *)createGeneralizedHoughGuil;

class func createGeneralizedHoughGuil() -> GeneralizedHoughGuil

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale
                                                    _quant:(double)_quant
                                                   _ang_th:(double)_ang_th
                                                  _log_eps:(double)_log_eps
                                               _density_th:(double)_density_th
                                                   _n_bins:(int)_n_bins;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double, _quant: Double, _ang_th: Double, _log_eps: Double, _density_th: Double, _n_bins: Int32) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale
                                                    _quant:(double)_quant
                                                   _ang_th:(double)_ang_th
                                                  _log_eps:(double)_log_eps
                                               _density_th:(double)_density_th;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double, _quant: Double, _ang_th: Double, _log_eps: Double, _density_th: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale
                                                    _quant:(double)_quant
                                                   _ang_th:(double)_ang_th
                                                  _log_eps:(double)_log_eps;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double, _quant: Double, _ang_th: Double, _log_eps: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale
                                                    _quant:(double)_quant
                                                   _ang_th:(double)_ang_th;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double, _quant: Double, _ang_th: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale
                                                    _quant:(double)_quant;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double, _quant: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale
                                              _sigma_scale:(double)_sigma_scale;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double, _sigma_scale: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
                                     (LineSegmentDetectorModes)_refine
                                                    _scale:(double)_scale;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes, _scale: Double) -> LineSegmentDetector

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.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector:
    (LineSegmentDetectorModes)_refine;

class func createLineSegmentDetector(_refine: LineSegmentDetectorModes) -> LineSegmentDetector

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.

is chosen.

+ (nonnull LineSegmentDetector *)createLineSegmentDetector;

class func createLineSegmentDetector() -> LineSegmentDetector

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.

+ (nonnull Rect2i *)boundingRect:(nonnull Mat *)array;

class func boundingRect(array: Mat) -> Rect2i

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 CITE: 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.

+ (nonnull RotatedRect *)fitEllipse:(nonnull NSArray<Point2f *> *)points;

class func fitEllipse(points: [Point2f]) -> RotatedRect

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 CITE: Taubin1991 is used.

For an ellipse, this basis set is

, which is a set of six free coefficients . However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths , the position , and the orientation . 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 where the matrices and are the partial derivatives of the design matrix with respect to x and y. The matrices are formed row by row applying the following to each of the points in the set: The AMS method minimizes the cost function

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

+ (nonnull RotatedRect *)fitEllipseAMS:(nonnull Mat *)points;

class func fitEllipseAMS(points: Mat) -> RotatedRect

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 CITE: Fitzgibbon1999 is used.

For an ellipse, this basis set is

, which is a set of six free coefficients . However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths , the position , and the orientation . 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 . The condition imposed is that which satisfies the inequality and as the coefficients can be arbitrarily scaled is not overly restrictive.

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

The system produces only one positive eigenvalue

which is chosen as the solution with its eigenvector . These are used to find the coefficients

The scaling factor guarantees that .

+ (nonnull RotatedRect *)fitEllipseDirect:(nonnull Mat *)points;

class func fitEllipseDirect(points: Mat) -> RotatedRect

Finds a rotated rectangle of the minimum area enclosing the input 2D point set.

The function calculates and returns the minimum-area bounding rectangle (possibly rotated) for a specified point set. Developer should keep in mind that the returned RotatedRect can contain negative indices when data is close to the containing Mat element boundary.

+ (nonnull RotatedRect *)minAreaRect:(nonnull NSArray<Point2f *> *)points;

class func minAreaRect(points: [Point2f]) -> RotatedRect

Calculates the width and height of a text string.

The function cv::getTextSize calculates and returns the size of a box that contains the specified text. That is, the following code renders some text, the tight box surrounding it, and the baseline: :

 String text = "Funny text inside the box";
 int fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
 double fontScale = 2;
 int thickness = 3;

 Mat img(600, 800, CV_8UC3, Scalar::all(0));

 int baseline=0;
 Size textSize = getTextSize(text, fontFace,
                             fontScale, thickness, &baseline);
 baseline += thickness;

 // center the text
 Point textOrg((img.cols - textSize.width)/2,
               (img.rows + textSize.height)/2);

 // draw the box
 rectangle(img, textOrg + Point(0, baseline),
           textOrg + Point(textSize.width, -textSize.height),
           Scalar(0,0,255));
 // ... and the baseline first
 line(img, textOrg + Point(0, thickness),
      textOrg + Point(textSize.width, thickness),
      Scalar(0, 0, 255));

 // then put the text itself
 putText(img, text, textOrg, fontFace, fontScale,
         Scalar::all(255), thickness, 8);

+ (nonnull Size2i *)getTextSize:(nonnull NSString *)text
                       fontFace:(HersheyFonts)fontFace
                      fontScale:(double)fontScale
                      thickness:(int)thickness
                       baseLine:(nonnull int *)baseLine;

class func getTextSize(text: String, fontFace: HersheyFonts, fontScale: Double, thickness: Int32, baseLine: UnsafeMutablePointer<Int32>) -> Size2i

+ (BOOL)clipLine:(nonnull Rect2i *)imgRect
             pt1:(nonnull Point2i *)pt1
             pt2:(nonnull Point2i *)pt2;

class func clipLine(imgRect: Rect2i, pt1: Point2i, pt2: Point2i) -> Bool

Tests a contour convexity.

The function tests whether the input contour is convex or not. The contour must be simple, that is, without self-intersections. Otherwise, the function output is undefined.

+ (BOOL)isContourConvex:(nonnull NSArray<Point2i *> *)contour;

class func isContourConvex(contour: [Point2i]) -> Bool

Calculates a contour perimeter or a curve length.

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

+ (double)arcLength:(nonnull NSArray<Point2f *> *)curve closed:(BOOL)closed;

class func arcLength(curve: [Point2f], closed: Bool) -> Double

Compares two histograms.

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

The function returns

.

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.

+ (double)compareHist:(nonnull Mat *)H1
                   H2:(nonnull Mat *)H2
               method:(HistCompMethods)method;

class func compareHist(H1: Mat, H2: Mat, method: HistCompMethods) -> Double

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<Point> 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<Point> approx;
 approxPolyDP(contour, approx, 5, true);
 double area1 = contourArea(approx);

 cout << "area0 =" << area0 << endl <<
         "area1 =" << area1 << endl <<
         "approx poly vertices" << approx.size() << endl;

+ (double)contourArea:(nonnull Mat *)contour oriented:(BOOL)oriented;

class func contourArea(contour: Mat, oriented: Bool) -> Double

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<Point> 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<Point> approx;
 approxPolyDP(contour, approx, 5, true);
 double area1 = contourArea(approx);

 cout << "area0 =" << area0 << endl <<
         "area1 =" << area1 << endl <<
         "approx poly vertices" << approx.size() << endl;

+ (double)contourArea:(nonnull Mat *)contour;

class func contourArea(contour: Mat) -> Double

Calculates the font-specific size to use to achieve a given height in pixels.

+ (double)getFontScaleFromHeight:(int)fontFace
                     pixelHeight:(int)pixelHeight
                       thickness:(int)thickness;

class func getFontScaleFromHeight(fontFace: Int32, pixelHeight: Int32, thickness: Int32) -> Double

Calculates the font-specific size to use to achieve a given height in pixels.

+ (double)getFontScaleFromHeight:(int)fontFace pixelHeight:(int)pixelHeight;

class func getFontScaleFromHeight(fontFace: Int32, pixelHeight: Int32) -> Double

Compares two shapes.

The function compares two shapes. All three implemented methods use the Hu invariants (see #HuMoments)

+ (double)matchShapes:(nonnull Mat *)contour1
             contour2:(nonnull Mat *)contour2
               method:(ShapeMatchModes)method
            parameter:(double)parameter;

class func matchShapes(contour1: Mat, contour2: Mat, method: ShapeMatchModes, parameter: Double) -> Double

Finds a triangle of minimum area enclosing a 2D point set and returns its area.

The function finds a triangle of minimum area enclosing the given set of 2D points and returns its area. The output for a given 2D point set is shown in the image below. 2D points are depicted in red* and the enclosing triangle in yellow.

The implementation of the algorithm is based on O'Rourke’s CITE: ORourke86 and Klee and Laskowski’s CITE: KleeLaskowski85 papers. O'Rourke provides a

algorithm for finding the minimal enclosing triangle of a 2D convex polygon with n vertices. Since the #minEnclosingTriangle function takes a 2D point set as input an additional preprocessing step of computing the convex hull of the 2D point set is required. The complexity of the #convexHull function is which is higher than . Thus the overall complexity of the function is .

+ (double)minEnclosingTriangle:(nonnull Mat *)points
                      triangle:(nonnull Mat *)triangle;

class func minEnclosingTriangle(points: Mat, triangle: Mat) -> Double

Performs a point-in-contour test.

The function determines whether the point is inside a contour, outside, or lies on an edge (or coincides with a vertex). It returns positive (inside), negative (outside), or zero (on an edge) value, correspondingly. When measureDist=false , the return value is +1, -1, and 0, respectively. Otherwise, the return value is a signed distance between the point and the nearest contour edge.

See below a sample output of the function where each image pixel is tested against the contour:

+ (double)pointPolygonTest:(nonnull NSArray<Point2f *> *)contour
                        pt:(nonnull Point2f *)pt
               measureDist:(BOOL)measureDist;

class func pointPolygonTest(contour: [Point2f], pt: Point2f, measureDist: Bool) -> Double

Applies a fixed-level threshold to each array element.

The function applies fixed-level thresholding to a multiple-channel array. The function is typically used to get a bi-level (binary) image out of a grayscale image ( #compare could be also used for this purpose) or for removing a noise, that is, filtering out pixels with too small or too large values. There are several types of thresholding supported by the function. They are determined by type parameter.

Also, the special values #THRESH_OTSU or #THRESH_TRIANGLE may be combined with one of the above values. In these cases, the function determines the optimal threshold value using the Otsu’s or Triangle algorithm and uses it instead of the specified thresh.

+ (double)threshold:(nonnull Mat *)src
                dst:(nonnull Mat *)dst
             thresh:(double)thresh
             maxval:(double)maxval
               type:(ThresholdTypes)type;

class func threshold(src: Mat, dst: Mat, thresh: Double, maxval: Double, type: ThresholdTypes) -> Double

Finds intersection of two convex polygons

+ (float)intersectConvexConvex:(nonnull Mat *)_p1
                           _p2:(nonnull Mat *)_p2
                          _p12:(nonnull Mat *)_p12
                  handleNested:(BOOL)handleNested;

class func intersectConvexConvex(_p1: Mat, _p2: Mat, _p12: Mat, handleNested: Bool) -> Float

Finds intersection of two convex polygons

+ (float)intersectConvexConvex:(nonnull Mat *)_p1
                           _p2:(nonnull Mat *)_p2
                          _p12:(nonnull Mat *)_p12;

class func intersectConvexConvex(_p1: Mat, _p2: Mat, _p12: Mat) -> Float

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 CITE: RubnerSept98, CITE: 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.

+ (float)EMD:(nonnull Mat *)signature1
    signature2:(nonnull Mat *)signature2
      distType:(DistanceTypes)distType
          cost:(nonnull Mat *)cost
          flow:(nonnull Mat *)flow;

class func wrapperEMD(signature1: Mat, signature2: Mat, distType: DistanceTypes, cost: Mat, flow: Mat) -> Float

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 CITE: RubnerSept98, CITE: 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.

+ (float)EMD:(nonnull Mat *)signature1
    signature2:(nonnull Mat *)signature2
      distType:(DistanceTypes)distType
          cost:(nonnull Mat *)cost;

class func wrapperEMD(signature1: Mat, signature2: Mat, distType: DistanceTypes, cost: Mat) -> Float

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 CITE: RubnerSept98, CITE: 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.

+ (float)EMD:(nonnull Mat *)signature1
    signature2:(nonnull Mat *)signature2
      distType:(DistanceTypes)distType;

class func wrapperEMD(signature1: Mat, signature2: Mat, distType: DistanceTypes) -> Float

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 Grana (BBDT) and Wu’s (SAUF) algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces a row major ordering of labels while BBDT does not. This function uses parallel version of both Grana and Wu’s 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.

+ (int)connectedComponentsWithAlgorithm:(nonnull Mat *)image
                                 labels:(nonnull Mat *)labels
                           connectivity:(int)connectivity
                                  ltype:(int)ltype
                                ccltype:(int)ccltype;

class func connectedComponents(image: Mat, labels: Mat, connectivity: Int32, ltype: Int32, ccltype: Int32) -> Int32

+ (int)connectedComponents:(nonnull Mat *)image
                    labels:(nonnull Mat *)labels
              connectivity:(int)connectivity
                     ltype:(int)ltype;

class func connectedComponents(image: Mat, labels: Mat, connectivity: Int32, ltype: Int32) -> Int32

+ (int)connectedComponents:(nonnull Mat *)image
                    labels:(nonnull Mat *)labels
              connectivity:(int)connectivity;

class func connectedComponents(image: Mat, labels: Mat, connectivity: Int32) -> Int32

+ (int)connectedComponents:(nonnull Mat *)image labels:(nonnull Mat *)labels;

class func connectedComponents(image: Mat, labels: Mat) -> Int32

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 Grana’s (BBDT) and Wu’s (SAUF) algorithms are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces a row major ordering of labels while BBDT does not. This function uses parallel version of both Grana and Wu’s 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.

+ (int)
    connectedComponentsWithStatsWithAlgorithm:(nonnull Mat *)image
                                       labels:(nonnull Mat *)labels
                                        stats:(nonnull Mat *)stats
                                    centroids:(nonnull Mat *)centroids
                                 connectivity:(int)connectivity
                                        ltype:(int)ltype
                                      ccltype:
                                          (ConnectedComponentsAlgorithmsTypes)
                                              ccltype;

class func connectedComponentsWithStats(image: Mat, labels: Mat, stats: Mat, centroids: Mat, connectivity: Int32, ltype: Int32, ccltype: ConnectedComponentsAlgorithmsTypes) -> Int32

+ (int)connectedComponentsWithStats:(nonnull Mat *)image
                             labels:(nonnull Mat *)labels
                              stats:(nonnull Mat *)stats
                          centroids:(nonnull Mat *)centroids
                       connectivity:(int)connectivity
                              ltype:(int)ltype;

class func connectedComponentsWithStats(image: Mat, labels: Mat, stats: Mat, centroids: Mat, connectivity: Int32, ltype: Int32) -> Int32

+ (int)connectedComponentsWithStats:(nonnull Mat *)image
                             labels:(nonnull Mat *)labels
                              stats:(nonnull Mat *)stats
                          centroids:(nonnull Mat *)centroids
                       connectivity:(int)connectivity;

class func connectedComponentsWithStats(image: Mat, labels: Mat, stats: Mat, centroids: Mat, connectivity: Int32) -> Int32

+ (int)connectedComponentsWithStats:(nonnull Mat *)image
                             labels:(nonnull Mat *)labels
                              stats:(nonnull Mat *)stats
                          centroids:(nonnull Mat *)centroids;

class func connectedComponentsWithStats(image: Mat, labels: Mat, stats: Mat, centroids: Mat) -> Int32

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

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

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.

+ (int)floodFill:(nonnull Mat *)image
            mask:(nonnull Mat *)mask
       seedPoint:(nonnull Point2i *)seedPoint
          newVal:(nonnull Scalar *)newVal
            rect:(nonnull Rect2i *)rect
          loDiff:(nonnull Scalar *)loDiff
          upDiff:(nonnull Scalar *)upDiff
           flags:(int)flags;

class func floodFill(image: Mat, mask: Mat, seedPoint: Point2i, newVal: Scalar, rect: Rect2i, loDiff: Scalar, upDiff: Scalar, flags: Int32) -> Int32

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

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

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.

+ (int)floodFill:(nonnull Mat *)image
            mask:(nonnull Mat *)mask
       seedPoint:(nonnull Point2i *)seedPoint
          newVal:(nonnull Scalar *)newVal
            rect:(nonnull Rect2i *)rect
          loDiff:(nonnull Scalar *)loDiff
          upDiff:(nonnull Scalar *)upDiff;

class func floodFill(image: Mat, mask: Mat, seedPoint: Point2i, newVal: Scalar, rect: Rect2i, loDiff: Scalar, upDiff: Scalar) -> Int32

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

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

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.

+ (int)floodFill:(nonnull Mat *)image
            mask:(nonnull Mat *)mask
       seedPoint:(nonnull Point2i *)seedPoint
          newVal:(nonnull Scalar *)newVal
            rect:(nonnull Rect2i *)rect
          loDiff:(nonnull Scalar *)loDiff;

class func floodFill(image: Mat, mask: Mat, seedPoint: Point2i, newVal: Scalar, rect: Rect2i, loDiff: Scalar) -> Int32

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

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

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.