@techstark/opencv-js 4.8.0-release.7 → 4.8.0-release.8

package/src/types/opencv/imgproc_shape.ts

@@ -0,0 +1,734 @@
+import {
+  bool,
+  double,
+  float,
+  InputArray,
+  int,
+  Moments,
+  OutputArray,
+  OutputArrayOfArrays,
+  Point,
+  Point2f,
+  Rect,
+  RotatedRect,
+} from "./_types";
+/*
+ * # Structural Analysis and Shape Descriptors
+ *
+ */
+/**
+ * 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
+ *
+ * @param curve Input vector of a 2D point stored in std::vector or Mat
+ *
+ * @param approxCurve Result of the approximation. The type should match the type of the input curve.
+ *
+ * @param epsilon Parameter specifying the approximation accuracy. This is the maximum distance between
+ * the original curve and its approximation.
+ *
+ * @param closed If true, the approximated curve is closed (its first and last vertices are connected).
+ * Otherwise, it is not closed.
+ */
+export declare function approxPolyDP(
+  curve: InputArray,
+  approxCurve: OutputArray,
+  epsilon: double,
+  closed: bool,
+): void;
+
+/**
+ * The function computes a curve length or a closed contour perimeter.
+ *
+ * @param curve Input vector of 2D points, stored in std::vector or Mat.
+ *
+ * @param closed Flag indicating whether the curve is closed or not.
+ */
+export declare function arcLength(curve: InputArray, closed: bool): double;
+
+/**
+ * The function calculates and returns the minimal up-right bounding rectangle for the specified point
+ * set or non-zero pixels of gray-scale image.
+ *
+ * @param array Input gray-scale image or 2D point set, stored in std::vector or Mat.
+ */
+export declare function boundingRect(array: InputArray): Rect;
+
+/**
+ * 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.
+ *
+ * @param box The input rotated rectangle. It may be the output of
+ *
+ * @param points The output array of four vertices of rectangles.
+ */
+export declare function boxPoints(box: RotatedRect, points: OutputArray): void;
+
+/**
+ * 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].
+ *
+ * @param image the 8-bit single-channel image to be labeled
+ *
+ * @param labels destination labeled image
+ *
+ * @param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
+ *
+ * @param ltype output image label type. Currently CV_32S and CV_16U are supported.
+ *
+ * @param ccltype connected components algorithm type (see the ConnectedComponentsAlgorithmsTypes).
+ */
+export declare function connectedComponents(
+  image: InputArray,
+  labels: OutputArray,
+  connectivity: int,
+  ltype: int,
+  ccltype: int,
+): int;
+
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ *
+ * @param image the 8-bit single-channel image to be labeled
+ *
+ * @param labels destination labeled image
+ *
+ * @param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
+ *
+ * @param ltype output image label type. Currently CV_32S and CV_16U are supported.
+ */
+export declare function connectedComponents(
+  image: InputArray,
+  labels: OutputArray,
+  connectivity?: int,
+  ltype?: int,
+): int;
+
+/**
+ * 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].
+ *
+ * @param image the 8-bit single-channel image to be labeled
+ *
+ * @param labels destination labeled image
+ *
+ * @param stats statistics output for each label, including the background label, see below for
+ * available statistics. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
+ * ConnectedComponentsTypes. The data type is CV_32S.
+ *
+ * @param centroids centroid 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.
+ *
+ * @param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
+ *
+ * @param ltype output image label type. Currently CV_32S and CV_16U are supported.
+ *
+ * @param ccltype connected components algorithm type (see ConnectedComponentsAlgorithmsTypes).
+ */
+export declare function connectedComponentsWithStats(
+  image: InputArray,
+  labels: OutputArray,
+  stats: OutputArray,
+  centroids: OutputArray,
+  connectivity: int,
+  ltype: int,
+  ccltype: int,
+): int;
+
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ *
+ * @param image the 8-bit single-channel image to be labeled
+ *
+ * @param labels destination labeled image
+ *
+ * @param stats statistics output for each label, including the background label, see below for
+ * available statistics. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
+ * ConnectedComponentsTypes. The data type is CV_32S.
+ *
+ * @param centroids centroid 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.
+ *
+ * @param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
+ *
+ * @param ltype output image label type. Currently CV_32S and CV_16U are supported.
+ */
+export declare function connectedComponentsWithStats(
+  image: InputArray,
+  labels: OutputArray,
+  stats: OutputArray,
+  centroids: OutputArray,
+  connectivity?: int,
+  ltype?: int,
+): int;
+
+/**
+ * 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:
+ *
+ * ```cpp
+ * 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;
+ * ```
+ *
+ * @param contour Input vector of 2D points (contour vertices), stored in std::vector or Mat.
+ *
+ * @param oriented Oriented 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.
+ */
+export declare function contourArea(
+  contour: InputArray,
+  oriented?: bool,
+): double;
+
+/**
+ * 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.
+ *
+ * `points` and `hull` should be different arrays, inplace processing isn't supported.
+ * Check [the corresponding tutorial] for more details.
+ *
+ * useful links:
+ *
+ * @param points Input 2D point set, stored in std::vector or Mat.
+ *
+ * @param hull Output 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.
+ *
+ * @param clockwise Orientation 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.
+ *
+ * @param returnPoints Operation 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.
+ */
+export declare function convexHull(
+  points: InputArray,
+  hull: OutputArray,
+  clockwise?: bool,
+  returnPoints?: bool,
+): void;
+
+/**
+ * The figure below displays convexity defects of a hand contour:
+ *
+ * @param contour Input contour.
+ *
+ * @param convexhull Convex hull obtained using convexHull that should contain indices of the contour
+ * points that make the hull.
+ *
+ * @param convexityDefects The 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.
+ */
+export declare function convexityDefects(
+  contour: InputArray,
+  convexhull: InputArray,
+  convexityDefects: OutputArray,
+): void;
+
+export declare function createGeneralizedHoughBallard(): any;
+
+export declare function createGeneralizedHoughGuil(): any;
+
+/**
+ * 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.
+ *
+ * Since opencv 3.2 source image is not modified by this function.
+ *
+ * @param image Source, 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).
+ *
+ * @param contours Detected contours. Each contour is stored as a vector of points (e.g.
+ * std::vector<std::vector<cv::Point> >).
+ *
+ * @param hierarchy Optional 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.
+ *
+ * @param mode Contour retrieval mode, see RetrievalModes
+ *
+ * @param method Contour approximation method, see ContourApproximationModes
+ *
+ * @param offset Optional 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.
+ */
+export declare function findContours(
+  image: InputArray,
+  contours: OutputArrayOfArrays,
+  hierarchy: OutputArray,
+  mode: int,
+  method: int,
+  offset?: Point,
+): void;
+
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function findContours(
+  image: InputArray,
+  contours: OutputArrayOfArrays,
+  mode: int,
+  method: int,
+  offset?: Point,
+): void;
+
+/**
+ * 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.
+ *
+ * @param points Input 2D point set, stored in std::vector<> or Mat
+ */
+export declare function fitEllipse(points: InputArray): RotatedRect;
+
+/**
+ * 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*}`
+ *
+ * @param points Input 2D point set, stored in std::vector<> or Mat
+ */
+export declare function fitEllipseAMS(points: InputArray): RotatedRect;
+
+/**
+ * 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$`.
+ *
+ * @param points Input 2D point set, stored in std::vector<> or Mat
+ */
+export declare function fitEllipseDirect(points: InputArray): RotatedRect;
+
+/**
+ * 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 (  ) 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)$` .
+ *
+ * @param points Input vector of 2D or 3D points, stored in std::vector<> or Mat.
+ *
+ * @param line Output 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.
+ *
+ * @param distType Distance used by the M-estimator, see DistanceTypes
+ *
+ * @param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value is
+ * chosen.
+ *
+ * @param reps Sufficient accuracy for the radius (distance between the coordinate origin and the
+ * line).
+ *
+ * @param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.
+ */
+export declare function fitLine(
+  points: InputArray,
+  line: OutputArray,
+  distType: int,
+  param: double,
+  reps: double,
+  aeps: double,
+): void;
+
+/**
+ * The function calculates seven Hu invariants (introduced in Hu62; see also ) defined as:
+ *
+ * `\\[\\begin{array}{l} hu[0]= \\eta _{20}+ \\eta _{02} \\\\ hu[1]=( \\eta _{20}- \\eta _{02})^{2}+4
+ * \\eta _{11}^{2} \\\\ hu[2]=( \\eta _{30}-3 \\eta _{12})^{2}+ (3 \\eta _{21}- \\eta _{03})^{2} \\\\
+ * hu[3]=( \\eta _{30}+ \\eta _{12})^{2}+ ( \\eta _{21}+ \\eta _{03})^{2} \\\\ hu[4]=( \\eta _{30}-3
+ * \\eta _{12})( \\eta _{30}+ \\eta _{12})[( \\eta _{30}+ \\eta _{12})^{2}-3( \\eta _{21}+ \\eta
+ * _{03})^{2}]+(3 \\eta _{21}- \\eta _{03})( \\eta _{21}+ \\eta _{03})[3( \\eta _{30}+ \\eta
+ * _{12})^{2}-( \\eta _{21}+ \\eta _{03})^{2}] \\\\ hu[5]=( \\eta _{20}- \\eta _{02})[( \\eta _{30}+
+ * \\eta _{12})^{2}- ( \\eta _{21}+ \\eta _{03})^{2}]+4 \\eta _{11}( \\eta _{30}+ \\eta _{12})( \\eta
+ * _{21}+ \\eta _{03}) \\\\ hu[6]=(3 \\eta _{21}- \\eta _{03})( \\eta _{21}+ \\eta _{03})[3( \\eta
+ * _{30}+ \\eta _{12})^{2}-( \\eta _{21}+ \\eta _{03})^{2}]-( \\eta _{30}-3 \\eta _{12})( \\eta _{21}+
+ * \\eta _{03})[3( \\eta _{30}+ \\eta _{12})^{2}-( \\eta _{21}+ \\eta _{03})^{2}] \\\\ \\end{array}\\]`
+ *
+ * where `$\\eta_{ji}$` stands for `$\\texttt{Moments::nu}_{ji}$` .
+ *
+ * These values are proved to be invariants to the image scale, rotation, and reflection except the
+ * seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of
+ * infinite image resolution. In case of raster images, the computed Hu invariants for the original and
+ * transformed images are a bit different.
+ *
+ * [matchShapes]
+ *
+ * @param moments Input moments computed with moments .
+ *
+ * @param hu Output Hu invariants.
+ */
+export declare function HuMoments(moments: any, hu: double): void;
+
+/**
+ * This is an overloaded member function, provided for convenience. It differs from the above function
+ * only in what argument(s) it accepts.
+ */
+export declare function HuMoments(m: any, hu: OutputArray): void;
+
+export declare function intersectConvexConvex(
+  _p1: InputArray,
+  _p2: InputArray,
+  _p12: OutputArray,
+  handleNested?: bool,
+): float;
+
+/**
+ * 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.
+ *
+ * @param contour Input vector of 2D points, stored in std::vector<> or Mat
+ */
+export declare function isContourConvex(contour: InputArray): bool;
+
+/**
+ * The function compares two shapes. All three implemented methods use the Hu invariants (see
+ * [HuMoments])
+ *
+ * @param contour1 First contour or grayscale image.
+ *
+ * @param contour2 Second contour or grayscale image.
+ *
+ * @param method Comparison method, see ShapeMatchModes
+ *
+ * @param parameter Method-specific parameter (not supported now).
+ */
+export declare function matchShapes(
+  contour1: InputArray,
+  contour2: InputArray,
+  method: int,
+  parameter: double,
+): double;
+
+/**
+ * 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.
+ *
+ * @param points Input vector of 2D points, stored in std::vector<> or Mat
+ */
+export declare function minAreaRect(points: InputArray): RotatedRect;
+
+/**
+ * The function finds the minimal enclosing circle of a 2D point set using an iterative algorithm.
+ *
+ * @param points Input vector of 2D points, stored in std::vector<> or Mat
+ *
+ * @param center Output center of the circle.
+ *
+ * @param radius Output radius of the circle.
+ */
+export declare function minEnclosingCircle(
+  points: InputArray,
+  center: any,
+  radius: any,
+): void;
+
+/**
+ * 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 ORourke86 and Klee and Laskowski's
+ * KleeLaskowski85 papers. O'Rourke provides a `$\\theta(n)$` 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 `$O(n log(n))$` which is
+ * higher than `$\\theta(n)$`. Thus the overall complexity of the function is `$O(n log(n))$`.
+ *
+ * @param points Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector<> or Mat
+ *
+ * @param triangle Output vector of three 2D points defining the vertices of the triangle. The depth of
+ * the OutputArray must be CV_32F.
+ */
+export declare function minEnclosingTriangle(
+  points: InputArray,
+  triangle: OutputArray,
+): double;
+
+/**
+ * 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].
+ *
+ * moments.
+ *
+ * Only applicable to contour moments calculations from Python bindings: Note that the numpy type for
+ * the input array should be either np.int32 or np.float32.
+ *
+ * [contourArea], [arcLength]
+ *
+ * @param array Raster image (single-channel, 8-bit or floating-point 2D array) or an array ( $1 \times
+ * N$ or $N \times 1$ ) of 2D points (Point or Point2f ).
+ *
+ * @param binaryImage If it is true, all non-zero image pixels are treated as 1's. The parameter is
+ * used for images only.
+ */
+export declare function moments(array: InputArray, binaryImage?: bool): Moments;
+
+/**
+ * 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:
+ *
+ * @param contour Input contour.
+ *
+ * @param pt Point tested against the contour.
+ *
+ * @param measureDist If true, the function estimates the signed distance from the point to the nearest
+ * contour edge. Otherwise, the function only checks if the point is inside a contour or not.
+ */
+export declare function pointPolygonTest(
+  contour: InputArray,
+  pt: Point2f,
+  measureDist: bool,
+): double;
+
+/**
+ * If there is then the vertices of the intersecting region are returned as well.
+ *
+ * Below are some examples of intersection configurations. The hatched pattern indicates the
+ * intersecting region and the red vertices are returned by the function.
+ *
+ * One of [RectanglesIntersectTypes]
+ *
+ * @param rect1 First rectangle
+ *
+ * @param rect2 Second rectangle
+ *
+ * @param intersectingRegion The output array of the vertices of the intersecting region. It returns at
+ * most 8 vertices. Stored as std::vector<cv::Point2f> or cv::Mat as Mx1 of type CV_32FC2.
+ */
+export declare function rotatedRectangleIntersection(
+  rect1: any,
+  rect2: any,
+  intersectingRegion: OutputArray,
+): int;
+
+export declare const CCL_WU: ConnectedComponentsAlgorithmsTypes; // initializer: = 0
+
+export declare const CCL_DEFAULT: ConnectedComponentsAlgorithmsTypes; // initializer: = -1
+
+export declare const CCL_GRANA: ConnectedComponentsAlgorithmsTypes; // initializer: = 1
+
+/**
+ * The leftmost (x) coordinate which is the inclusive start of the bounding box in the horizontal
+ * direction.
+ *
+ */
+export declare const CC_STAT_LEFT: ConnectedComponentsTypes; // initializer: = 0
+
+/**
+ * The topmost (y) coordinate which is the inclusive start of the bounding box in the vertical
+ * direction.
+ *
+ */
+export declare const CC_STAT_TOP: ConnectedComponentsTypes; // initializer: = 1
+
+export declare const CC_STAT_WIDTH: ConnectedComponentsTypes; // initializer: = 2
+
+export declare const CC_STAT_HEIGHT: ConnectedComponentsTypes; // initializer: = 3
+
+export declare const CC_STAT_AREA: ConnectedComponentsTypes; // initializer: = 4
+
+export declare const CC_STAT_MAX: ConnectedComponentsTypes; // initializer: = 5
+
+/**
+ * stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and (x2,y2) of
+ * the contour will be either horizontal, vertical or diagonal neighbors, that is,
+ * max(abs(x1-x2),abs(y2-y1))==1.
+ *
+ */
+export declare const CHAIN_APPROX_NONE: ContourApproximationModes; // initializer: = 1
+
+/**
+ * compresses horizontal, vertical, and diagonal segments and leaves only their end points. For
+ * example, an up-right rectangular contour is encoded with 4 points.
+ *
+ */
+export declare const CHAIN_APPROX_SIMPLE: ContourApproximationModes; // initializer: = 2
+
+/**
+ * applies one of the flavors of the Teh-Chin chain approximation algorithm TehChin89
+ *
+ */
+export declare const CHAIN_APPROX_TC89_L1: ContourApproximationModes; // initializer: = 3
+
+/**
+ * applies one of the flavors of the Teh-Chin chain approximation algorithm TehChin89
+ *
+ */
+export declare const CHAIN_APPROX_TC89_KCOS: ContourApproximationModes; // initializer: = 4
+
+export declare const INTERSECT_NONE: RectanglesIntersectTypes; // initializer: = 0
+
+export declare const INTERSECT_PARTIAL: RectanglesIntersectTypes; // initializer: = 1
+
+export declare const INTERSECT_FULL: RectanglesIntersectTypes; // initializer: = 2
+
+/**
+ * retrieves only the extreme outer contours. It sets `hierarchy[i][2]=hierarchy[i][3]=-1` for all the
+ * contours.
+ *
+ */
+export declare const RETR_EXTERNAL: RetrievalModes; // initializer: = 0
+
+/**
+ * retrieves all of the contours without establishing any hierarchical relationships.
+ *
+ */
+export declare const RETR_LIST: RetrievalModes; // initializer: = 1
+
+/**
+ * retrieves all of the contours and organizes them into a two-level hierarchy. At the top level, there
+ * are external boundaries of the components. At the second level, there are boundaries of the holes.
+ * If there is another contour inside a hole of a connected component, it is still put at the top
+ * level.
+ *
+ */
+export declare const RETR_CCOMP: RetrievalModes; // initializer: = 2
+
+/**
+ * retrieves all of the contours and reconstructs a full hierarchy of nested contours.
+ *
+ */
+export declare const RETR_TREE: RetrievalModes; // initializer: = 3
+
+export declare const RETR_FLOODFILL: RetrievalModes; // initializer: = 4
+
+export declare const CONTOURS_MATCH_I1: ShapeMatchModes; // initializer: =1
+
+export declare const CONTOURS_MATCH_I2: ShapeMatchModes; // initializer: =2
+
+export declare const CONTOURS_MATCH_I3: ShapeMatchModes; // initializer: =3
+
+export type ConnectedComponentsAlgorithmsTypes = any;
+
+export type ConnectedComponentsTypes = any;
+
+export type ContourApproximationModes = any;
+
+export type RectanglesIntersectTypes = any;
+
+export type RetrievalModes = any;
+
+export type ShapeMatchModes = any;