@opencvjs/types 4.10.0-release.1

package/lib/opencv/MatExpr.d.ts

@@ -0,0 +1,107 @@
+import type { double, int, Mat, MatOp, Scalar } from "./_types";
+
+/**
+ * <a name="d1/d10/classcv_1_1MatExpr_1MatrixExpressions"></a>This is a list of implemented matrix
+ * operations that can be combined in arbitrary complex expressions (here A, B stand for matrices (
+ * [Mat](#d3/d63/classcv_1_1Mat}) ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double
+ * )):
+ *
+ * Addition, subtraction, negation: `A+B`, `A-B`, `A+s`, `A-s`, `s+A`, `s-A`, `-A`
+ * Scaling: `A*alpha`
+ * Per-element multiplication and division: `A.mul(B)`, `A/B`, `alpha/A`
+ * Matrix multiplication: `A*B`
+ * Transposition: `A.t()` (means A)
+ * Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems:
+ * `A.inv([method]) (~ A<sup>-1</sup>)`, `A.inv([method])*B (~ X: AX=B)`
+ * Comparison: `A cmpop B`, `A cmpop alpha`, `alpha cmpop A`, where *cmpop* is one of `>`, `>=`, `==`,
+ * `!=`, `<=`, `<`. The result of comparison is an 8-bit single channel mask whose elements are set to
+ * 255 (if the particular element or pair of elements satisfy the condition) or 0.
+ * Bitwise logical operations: `A logicop B`, `A logicop s`, `s logicop A`, `~A`, where *logicop* is
+ * one of `&`, `|`, `^`.
+ * Element-wise minimum and maximum: `min(A, B)`, `min(A, alpha)`, `max(A, B)`, `max(A, alpha)`
+ * Element-wise absolute value: `abs(A)`
+ * Cross-product, dot-product: `A.cross(B)`, `A.dot(B)`
+ * Any function of matrix or matrices and scalars that returns a matrix or a scalar, such as norm,
+ * mean, sum, countNonZero, trace, determinant, repeat, and others.
+ * Matrix initializers ( [Mat::eye()](#d3/d63/classcv_1_1Mat_1a2cf9b9acde7a9852542bbc20ef851ed2}),
+ * [Mat::zeros()](#d3/d63/classcv_1_1Mat_1a0b57b6a326c8876d944d188a46e0f556}),
+ * [Mat::ones()](#d3/d63/classcv_1_1Mat_1a69ae0402d116fc9c71908d8508dc2f09}) ), matrix comma-separated
+ * initializers, matrix constructors and operators that extract sub-matrices (see
+ * [Mat](#d3/d63/classcv_1_1Mat}) description).
+ * Mat_<destination_type>() constructors to cast the result to the proper type.
+ *
+ * Comma-separated initializers and probably some other operations may require additional explicit
+ * Mat() or Mat_<T>() constructor calls to resolve a possible ambiguity.
+ * Here are examples of matrix expressions:
+ *
+ * ```cpp
+ * // compute pseudo-inverse of A, equivalent to A.inv(DECOMP_SVD)
+ * SVD svd(A);
+ * Mat pinvA = svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t();
+ *
+ * // compute the new vector of parameters in the Levenberg-Marquardt algorithm
+ * x -= (A.t()*A + lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err);
+ *
+ * // sharpen image using "unsharp mask" algorithm
+ * Mat blurred; double sigma = 1, threshold = 5, amount = 1;
+ * GaussianBlur(img, blurred, Size(), sigma, sigma);
+ * Mat lowContrastMask = abs(img - blurred) < threshold;
+ * Mat sharpened = img*(1+amount) + blurred*(-amount);
+ * img.copyTo(sharpened, lowContrastMask);
+ * ```
+ *
+ * Source:
+ * [opencv2/core/mat.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/mat.hpp#L3557).
+ *
+ */
+export declare class MatExpr extends Mat {
+  public a: Mat;
+
+  public alpha: double;
+
+  public b: Mat;
+
+  public beta: double;
+
+  public c: Mat;
+
+  public flags: int;
+
+  public op: MatOp;
+
+  public s: Scalar;
+
+  public constructor();
+
+  public constructor(m: Mat);
+
+  public constructor(
+    _op: MatOp,
+    _flags: int,
+    _a?: Mat,
+    _b?: Mat,
+    _c?: Mat,
+    _alpha?: double,
+    _beta?: double,
+    _s?: Scalar,
+  );
+
+  public col(x: int): MatExpr;
+
+  public cross(m: Mat): Mat;
+
+  public diag(d?: int): MatExpr;
+
+  public dot(m: Mat): Mat;
+
+  public inv(method?: int): MatExpr;
+
+  public mul(e: MatExpr, scale?: double): MatExpr;
+
+  public mul(m: Mat, scale?: double): MatExpr;
+
+  public row(y: int): MatExpr;
+  public t(): MatExpr;
+
+  public type(): int;
+}

package/lib/opencv/MatOp.d.ts

@@ -0,0 +1,72 @@
+import type { Mat, MatExpr } from "./_types";
+import type { double, int } from "./missing";
+import type { Scalar, Size } from "./helpers";
+
+export declare class MatOp {
+  public constructor();
+
+  public abs(expr: MatExpr, res: MatExpr): MatExpr;
+
+  public add(expr1: MatExpr, expr2: MatExpr, res: MatExpr): MatExpr;
+
+  public add(expr1: MatExpr, s: Scalar, res: MatExpr): MatExpr;
+
+  public assign(expr: MatExpr, m: Mat, type?: int): MatExpr;
+
+  public augAssignAdd(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignAnd(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignDivide(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignMultiply(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignOr(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignSubtract(expr: MatExpr, m: Mat): MatExpr;
+
+  public augAssignXor(expr: MatExpr, m: Mat): MatExpr;
+
+  public diag(expr: MatExpr, d: int, res: MatExpr): MatExpr;
+
+  public divide(
+    expr1: MatExpr,
+    expr2: MatExpr,
+    res: MatExpr,
+    scale?: double,
+  ): MatExpr;
+
+  public divide(s: double, expr: MatExpr, res: MatExpr): MatExpr;
+
+  public elementWise(expr: MatExpr): MatExpr;
+
+  public invert(expr: MatExpr, method: int, res: MatExpr): MatExpr;
+
+  public matmul(expr1: MatExpr, expr2: MatExpr, res: MatExpr): MatExpr;
+
+  public multiply(
+    expr1: MatExpr,
+    expr2: MatExpr,
+    res: MatExpr,
+    scale?: double,
+  ): MatExpr;
+
+  public multiply(expr1: MatExpr, s: double, res: MatExpr): MatExpr;
+
+  public roi(
+    expr: MatExpr,
+    rowRange: Range,
+    colRange: Range,
+    res: MatExpr,
+  ): MatExpr;
+
+  public size(expr: MatExpr): Size;
+
+  public subtract(expr1: MatExpr, expr2: MatExpr, res: MatExpr): MatExpr;
+
+  public subtract(s: Scalar, expr: MatExpr, res: MatExpr): Scalar;
+
+  public transpose(expr: MatExpr, res: MatExpr): MatExpr;
+
+  public type(expr: MatExpr): MatExpr;
+}

package/lib/opencv/Matx.d.ts

@@ -0,0 +1,228 @@
+import type {
+  diag_type,
+  int,
+  Matx_AddOp,
+  Matx_DivOp,
+  Matx_MatMulOp,
+  Matx_MulOp,
+  Matx_ScaleOp,
+  Matx_SubOp,
+  Matx_TOp,
+  Vec,
+  _T2,
+  _Tp,
+} from "./_types";
+
+/**
+ * If you need a more flexible type, use [Mat](#d3/d63/classcv_1_1Mat}) . The elements of the matrix M
+ * are accessible using the M(i,j) notation. Most of the common matrix operations (see also
+ * [MatrixExpressions](#d1/d10/classcv_1_1MatExpr_1MatrixExpressions}) ) are available. To do an
+ * operation on [Matx](#de/de1/classcv_1_1Matx}) that is not implemented, you can easily convert the
+ * matrix to [Mat](#d3/d63/classcv_1_1Mat}) and backwards:
+ *
+ * ```cpp
+ * Matx33f m(1, 2, 3,
+ *           4, 5, 6,
+ *           7, 8, 9);
+ * cout << sum(Mat(m*m.t())) << endl;
+ * ```
+ *
+ *  Except of the plain constructor which takes a list of elements, [Matx](#de/de1/classcv_1_1Matx})
+ * can be initialized from a C-array:
+ *
+ * ```cpp
+ * float values[] = { 1, 2, 3};
+ * Matx31f m(values);
+ * ```
+ *
+ *  In case if C++11 features are available, std::initializer_list can be also used to initialize
+ * [Matx](#de/de1/classcv_1_1Matx}):
+ *
+ * ```cpp
+ * Matx31f m = { 1, 2, 3};
+ * ```
+ *
+ * Source:
+ * [opencv2/core/matx.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/matx.hpp#L1185).
+ *
+ */
+export declare class Matx {
+  public val: _Tp;
+
+  public constructor();
+
+  public constructor(v0: _Tp);
+
+  public constructor(v0: _Tp, v1: _Tp);
+
+  public constructor(v0: _Tp, v1: _Tp, v2: _Tp);
+
+  public constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp);
+
+  public constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp);
+
+  public constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp);
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+    v8: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+    v8: _Tp,
+    v9: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+    v8: _Tp,
+    v9: _Tp,
+    v10: _Tp,
+    v11: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+    v8: _Tp,
+    v9: _Tp,
+    v10: _Tp,
+    v11: _Tp,
+    v12: _Tp,
+    v13: _Tp,
+  );
+
+  public constructor(
+    v0: _Tp,
+    v1: _Tp,
+    v2: _Tp,
+    v3: _Tp,
+    v4: _Tp,
+    v5: _Tp,
+    v6: _Tp,
+    v7: _Tp,
+    v8: _Tp,
+    v9: _Tp,
+    v10: _Tp,
+    v11: _Tp,
+    v12: _Tp,
+    v13: _Tp,
+    v14: _Tp,
+    v15: _Tp,
+  );
+
+  public constructor(vals: any);
+
+  public constructor(arg334: any);
+
+  public constructor(a: Matx, b: Matx, arg335: Matx_AddOp);
+
+  public constructor(a: Matx, b: Matx, arg336: Matx_SubOp);
+
+  public constructor(arg337: any, a: Matx, alpha: _T2, arg338: Matx_ScaleOp);
+
+  public constructor(a: Matx, b: Matx, arg339: Matx_MulOp);
+
+  public constructor(a: Matx, b: Matx, arg340: Matx_DivOp);
+
+  public constructor(l: int, a: Matx, b: Matx, arg341: Matx_MatMulOp);
+
+  public constructor(a: Matx, arg342: Matx_TOp);
+
+  public col(i: int): Matx;
+
+  public ddot(v: Matx): Matx;
+
+  public diag(): diag_type;
+
+  public div(a: Matx): Matx;
+
+  public dot(v: Matx): Matx;
+
+  public get_minor(m1: int, n1: int, base_row: int, base_col: int): Matx;
+
+  public inv(method?: int, p_is_ok?: any): Matx;
+
+  public mul(a: Matx): Matx;
+
+  public reshape(m1: int, n1: int): Matx;
+
+  public row(i: int): Matx;
+
+  public solve(l: int, rhs: Matx, flags?: int): Matx;
+
+  public solve(rhs: Vec, method: int): Vec;
+
+  public t(): Matx;
+
+  public static all(alpha: _Tp): Matx;
+
+  public static diag(d: diag_type): Matx;
+
+  public static eye(): Matx;
+
+  public static ones(): Matx;
+
+  public static randn(a: _Tp, b: _Tp): Matx;
+
+  public static randu(a: _Tp, b: _Tp): Matx;
+
+  public static zeros(): Matx;
+}
+
+export declare const rows: any; // initializer: = m
+
+export declare const cols: any; // initializer: = n
+
+export declare const channels: any; // initializer: = rows*cols
+
+export declare const shortdim: any; // initializer: = (m < n ? m : n)

package/lib/opencv/Node.d.ts

@@ -0,0 +1,33 @@
+import type { double, int } from "./_types";
+
+export declare class Node {
+  /**
+   *   Class index normalized to 0..class_count-1 range and assigned to the node. It is used internally
+   * in classification trees and tree ensembles.
+   *
+   */
+  public classIdx: int;
+
+  /**
+   *   Default direction where to go (-1: left or +1: right). It helps in the case of missing values.
+   *
+   */
+  public defaultDir: int;
+
+  public left: int;
+
+  public parent: int;
+
+  public right: int;
+
+  public split: int;
+
+  /**
+   *   Value at the node: a class label in case of classification or estimated function value in case of
+   * regression.
+   *
+   */
+  public value: double;
+
+  public constructor();
+}

package/lib/opencv/ORB.d.ts

@@ -0,0 +1,23 @@
+import type { Feature2D } from "./_types";
+import type { float, int } from "./missing";
+
+/**
+ * https://docs.opencv.org/4.10.0/db/d95/classcv_1_1ORB.html
+ */
+export declare class ORB extends Feature2D {
+  public constructor(
+    nfeatures?: int,
+    scaleFactor?: float,
+    nlevels?: int,
+    edgeThreshold?: int,
+    firstLevel?: int,
+    WTA_K?: int,
+    scoreType?: ORBScoreType,
+    patchSize?: int,
+    fastThreshold?: int,
+  );
+}
+
+type ORBScoreType = int;
+export declare const ORB_HARRIS_SCORE: ORBScoreType;
+export declare const ORB_FAST_SCORE: ORBScoreType;

package/lib/opencv/PCA.d.ts

@@ -0,0 +1,198 @@
+import type { InputArray, OutputArray } from "./helpers";
+import type { double, FileNode, FileStorage, int } from "./missing";
+import type { Mat } from "./Mat";
+
+/**
+ * The class is used to calculate a special basis for a set of vectors. The basis will consist of
+ * eigenvectors of the covariance matrix calculated from the input set of vectors. The class PCA can
+ * also transform vectors to/from the new coordinate space defined by the basis. Usually, in this new
+ * coordinate system, each vector from the original set (and any linear combination of such vectors)
+ * can be quite accurately approximated by taking its first few components, corresponding to the
+ * eigenvectors of the largest eigenvalues of the covariance matrix. Geometrically it means that you
+ * calculate a projection of the vector to a subspace formed by a few eigenvectors corresponding to the
+ * dominant eigenvalues of the covariance matrix. And usually such a projection is very close to the
+ * original vector. So, you can represent the original vector from a high-dimensional space with a much
+ * shorter vector consisting of the projected vector's coordinates in the subspace. Such a
+ * transformation is also known as Karhunen-Loeve Transform, or KLT. See
+ *
+ * The sample below is the function that takes two matrices. The first function stores a set of vectors
+ * (a row per vector) that is used to calculate [PCA](#d3/d8d/classcv_1_1PCA}). The second function
+ * stores another "test" set of vectors (a row per vector). First, these vectors are compressed with
+ * [PCA](#d3/d8d/classcv_1_1PCA}), then reconstructed back, and then the reconstruction error norm is
+ * computed and printed for each vector. :
+ *
+ * ```cpp
+ * using namespace cv;
+ *
+ * PCA compressPCA(const Mat& pcaset, int maxComponents,
+ *                 const Mat& testset, Mat& compressed)
+ * {
+ *     PCA pca(pcaset, // pass the data
+ *             Mat(), // we do not have a pre-computed mean vector,
+ *                    // so let the PCA engine to compute it
+ *             PCA::DATA_AS_ROW, // indicate that the vectors
+ *                                 // are stored as matrix rows
+ *                                 // (use PCA::DATA_AS_COL if the vectors are
+ *                                 // the matrix columns)
+ *             maxComponents // specify, how many principal components to retain
+ *             );
+ *     // if there is no test data, just return the computed basis, ready-to-use
+ *     if( !testset.data )
+ *         return pca;
+ *     CV_Assert( testset.cols == pcaset.cols );
+ *
+ *     compressed.create(testset.rows, maxComponents, testset.type());
+ *
+ *     Mat reconstructed;
+ *     for( int i = 0; i < testset.rows; i++ )
+ *     {
+ *         Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed;
+ *         // compress the vector, the result will be stored
+ *         // in the i-th row of the output matrix
+ *         pca.project(vec, coeffs);
+ *         // and then reconstruct it
+ *         pca.backProject(coeffs, reconstructed);
+ *         // and measure the error
+ *         printf("%d. diff = %g\\n", i, norm(vec, reconstructed, NORM_L2));
+ *     }
+ *     return pca;
+ * }
+ * ```
+ *
+ * [calcCovarMatrix](#d2/de8/group__core__array_1gae6ffa9354633f984246945d52823165d}),
+ * [mulTransposed](#d2/de8/group__core__array_1gadc4e49f8f7a155044e3be1b9e3b270ab}),
+ * [SVD](#df/df7/classcv_1_1SVD}),
+ * [dft](#d2/de8/group__core__array_1gadd6cf9baf2b8b704a11b5f04aaf4f39d}),
+ * [dct](#d2/de8/group__core__array_1ga85aad4d668c01fbd64825f589e3696d4})
+ *
+ * Source:
+ * [opencv2/core.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core.hpp#L2393).
+ *
+ */
+export declare class PCA {
+  public eigenvalues: Mat;
+
+  public eigenvectors: Mat;
+
+  public mean: Mat;
+
+  /**
+   *   The default constructor initializes an empty PCA structure. The other constructors initialize the
+   * structure and call [PCA::operator()()].
+   */
+  public constructor();
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   *
+   * @param data input samples stored as matrix rows or matrix columns.
+   *
+   * @param mean optional mean value; if the matrix is empty (noArray()), the mean is computed from the
+   * data.
+   *
+   * @param flags operation flags; currently the parameter is only used to specify the data layout
+   * (PCA::Flags)
+   *
+   * @param maxComponents maximum number of components that PCA should retain; by default, all the
+   * components are retained.
+   */
+  public constructor(
+    data: InputArray,
+    mean: InputArray,
+    flags: int,
+    maxComponents?: int,
+  );
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   *
+   * @param data input samples stored as matrix rows or matrix columns.
+   *
+   * @param mean optional mean value; if the matrix is empty (noArray()), the mean is computed from the
+   * data.
+   *
+   * @param flags operation flags; currently the parameter is only used to specify the data layout
+   * (PCA::Flags)
+   *
+   * @param retainedVariance Percentage of variance that PCA should retain. Using this parameter will
+   * let the PCA decided how many components to retain but it will always keep at least 2.
+   */
+  public constructor(
+    data: InputArray,
+    mean: InputArray,
+    flags: int,
+    retainedVariance: double,
+  );
+
+  /**
+   *   The methods are inverse operations to [PCA::project]. They take PC coordinates of projected
+   * vectors and reconstruct the original vectors. Unless all the principal components have been
+   * retained, the reconstructed vectors are different from the originals. But typically, the difference
+   * is small if the number of components is large enough (but still much smaller than the original
+   * vector dimensionality). As a result, [PCA] is used.
+   *
+   * @param vec coordinates of the vectors in the principal component subspace, the layout and size are
+   * the same as of PCA::project output vectors.
+   */
+  public backProject(vec: InputArray): Mat;
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   *
+   * @param vec coordinates of the vectors in the principal component subspace, the layout and size are
+   * the same as of PCA::project output vectors.
+   *
+   * @param result reconstructed vectors; the layout and size are the same as of PCA::project input
+   * vectors.
+   */
+  public backProject(vec: InputArray, result: OutputArray): InputArray;
+
+  /**
+   *   The methods project one or more vectors to the principal component subspace, where each vector
+   * projection is represented by coefficients in the principal component basis. The first form of the
+   * method returns the matrix that the second form writes to the result. So the first form can be used
+   * as a part of expression while the second form can be more efficient in a processing loop.
+   *
+   * @param vec input vector(s); must have the same dimensionality and the same layout as the input
+   * data used at PCA phase, that is, if DATA_AS_ROW are specified, then vec.cols==data.cols (vector
+   * dimensionality) and vec.rows is the number of vectors to project, and the same is true for the
+   * PCA::DATA_AS_COL case.
+   */
+  public project(vec: InputArray): Mat;
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   *
+   * @param vec input vector(s); must have the same dimensionality and the same layout as the input
+   * data used at PCA phase, that is, if DATA_AS_ROW are specified, then vec.cols==data.cols (vector
+   * dimensionality) and vec.rows is the number of vectors to project, and the same is true for the
+   * PCA::DATA_AS_COL case.
+   *
+   * @param result output vectors; in case of PCA::DATA_AS_COL, the output matrix has as many columns
+   * as the number of input vectors, this means that result.cols==vec.cols and the number of rows match
+   * the number of principal components (for example, maxComponents parameter passed to the constructor).
+   */
+  public project(vec: InputArray, result: OutputArray): InputArray;
+
+  /**
+   *   Loads [eigenvalues] [eigenvectors] and [mean] from specified [FileNode]
+   */
+  public read(fn: FileNode): FileNode;
+
+  /**
+   *   Writes [eigenvalues] [eigenvectors] and [mean] to specified [FileStorage]
+   */
+  public write(fs: FileStorage): FileStorage;
+}
+
+export declare const DATA_AS_ROW: Flags; // initializer: = 0
+
+export declare const DATA_AS_COL: Flags; // initializer: = 1
+
+export declare const USE_AVG: Flags; // initializer: = 2
+
+export type Flags = any;