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

package/dist/src/types/opencv/Mat.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Mat.js.map

package/dist/src/types/opencv/Mat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mat.js","sourceRoot":"","sources":["../../../../src/types/opencv/Mat.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/MatExpr.d.ts

@@ -0,0 +1,78 @@
+import { 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 {
+    a: Mat;
+    alpha: double;
+    b: Mat;
+    beta: double;
+    c: Mat;
+    flags: int;
+    op: MatOp;
+    s: Scalar;
+    constructor();
+    constructor(m: Mat);
+    constructor(_op: MatOp, _flags: int, _a?: Mat, _b?: Mat, _c?: Mat, _alpha?: double, _beta?: double, _s?: Scalar);
+    col(x: int): MatExpr;
+    cross(m: Mat): Mat;
+    diag(d?: int): MatExpr;
+    dot(m: Mat): Mat;
+    inv(method?: int): MatExpr;
+    mul(e: MatExpr, scale?: double): MatExpr;
+    mul(m: Mat, scale?: double): MatExpr;
+    row(y: int): MatExpr;
+    t(): MatExpr;
+    type(): int;
+}

package/dist/src/types/opencv/MatExpr.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _types_1 = require("./_types");
+//# sourceMappingURL=MatExpr.js.map

package/dist/src/types/opencv/MatExpr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatExpr.js","sourceRoot":"","sources":["../../../../src/types/opencv/MatExpr.ts"],"names":[],"mappings":";;AAAA,qCAA2D"}

package/dist/src/types/opencv/MatOp.d.ts

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

package/dist/src/types/opencv/MatOp.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MatOp.js.map

package/dist/src/types/opencv/MatOp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatOp.js","sourceRoot":"","sources":["../../../../src/types/opencv/MatOp.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/Matx.d.ts

@@ -0,0 +1,84 @@
+import { 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 {
+    val: _Tp;
+    constructor();
+    constructor(v0: _Tp);
+    constructor(v0: _Tp, v1: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp, v6: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp, v6: _Tp, v7: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp, v6: _Tp, v7: _Tp, v8: _Tp);
+    constructor(v0: _Tp, v1: _Tp, v2: _Tp, v3: _Tp, v4: _Tp, v5: _Tp, v6: _Tp, v7: _Tp, v8: _Tp, v9: _Tp);
+    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);
+    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);
+    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);
+    constructor(vals: any);
+    constructor(arg334: any);
+    constructor(a: Matx, b: Matx, arg335: Matx_AddOp);
+    constructor(a: Matx, b: Matx, arg336: Matx_SubOp);
+    constructor(arg337: any, a: Matx, alpha: _T2, arg338: Matx_ScaleOp);
+    constructor(a: Matx, b: Matx, arg339: Matx_MulOp);
+    constructor(a: Matx, b: Matx, arg340: Matx_DivOp);
+    constructor(l: int, a: Matx, b: Matx, arg341: Matx_MatMulOp);
+    constructor(a: Matx, arg342: Matx_TOp);
+    col(i: int): Matx;
+    ddot(v: Matx): Matx;
+    diag(): diag_type;
+    div(a: Matx): Matx;
+    dot(v: Matx): Matx;
+    get_minor(m1: int, n1: int, base_row: int, base_col: int): Matx;
+    inv(method?: int, p_is_ok?: any): Matx;
+    mul(a: Matx): Matx;
+    reshape(m1: int, n1: int): Matx;
+    row(i: int): Matx;
+    solve(l: int, rhs: Matx, flags?: int): Matx;
+    solve(rhs: Vec, method: int): Vec;
+    t(): Matx;
+    static all(alpha: _Tp): Matx;
+    static diag(d: diag_type): Matx;
+    static eye(): Matx;
+    static ones(): Matx;
+    static randn(a: _Tp, b: _Tp): Matx;
+    static randu(a: _Tp, b: _Tp): Matx;
+    static zeros(): Matx;
+}
+export declare const rows: any;
+export declare const cols: any;
+export declare const channels: any;
+export declare const shortdim: any;

package/dist/src/types/opencv/Matx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Matx.js.map

package/dist/src/types/opencv/Matx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matx.js","sourceRoot":"","sources":["../../../../src/types/opencv/Matx.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/Node.d.ts

@@ -0,0 +1,25 @@
+import { 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.
+     *
+     */
+    classIdx: int;
+    /**
+     *   Default direction where to go (-1: left or +1: right). It helps in the case of missing values.
+     *
+     */
+    defaultDir: int;
+    left: int;
+    parent: int;
+    right: int;
+    split: int;
+    /**
+     *   Value at the node: a class label in case of classification or estimated function value in case of
+     * regression.
+     *
+     */
+    value: double;
+    constructor();
+}

package/dist/src/types/opencv/Node.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Node.js.map

package/dist/src/types/opencv/Node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.js","sourceRoot":"","sources":["../../../../src/types/opencv/Node.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/ORB.d.ts

@@ -0,0 +1,11 @@
+import { Feature2D, float, int } from "./_types";
+/**
+ * https://docs.opencv.org/4.8.0/db/d95/classcv_1_1ORB.html
+ */
+export declare class ORB extends Feature2D {
+    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;
+export {};

package/dist/src/types/opencv/ORB.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _types_1 = require("./_types");
+//# sourceMappingURL=ORB.js.map

package/dist/src/types/opencv/ORB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ORB.js","sourceRoot":"","sources":["../../../../src/types/opencv/ORB.ts"],"names":[],"mappings":";;AAAA,qCAAiD"}

package/dist/src/types/opencv/PCA.d.ts

@@ -0,0 +1,170 @@
+import { double, FileNode, FileStorage, InputArray, int, Mat, OutputArray } from "./_types";
+/**
+ * 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 {
+    eigenvalues: Mat;
+    eigenvectors: Mat;
+    mean: Mat;
+    /**
+     *   The default constructor initializes an empty PCA structure. The other constructors initialize the
+     * structure and call [PCA::operator()()].
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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).
+     */
+    project(vec: InputArray, result: OutputArray): InputArray;
+    /**
+     *   Loads [eigenvalues] [eigenvectors] and [mean] from specified [FileNode]
+     */
+    read(fn: FileNode): FileNode;
+    /**
+     *   Writes [eigenvalues] [eigenvectors] and [mean] to specified [FileStorage]
+     */
+    write(fs: FileStorage): FileStorage;
+}
+export declare const DATA_AS_ROW: Flags;
+export declare const DATA_AS_COL: Flags;
+export declare const USE_AVG: Flags;
+export type Flags = any;

package/dist/src/types/opencv/PCA.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PCA.js.map

package/dist/src/types/opencv/PCA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PCA.js","sourceRoot":"","sources":["../../../../src/types/opencv/PCA.ts"],"names":[],"mappings":""}

package/dist/src/types/opencv/RotatedRect.d.ts

@@ -0,0 +1,63 @@
+import { float, Point2f, Rect, Rect_, Size2f } from "./_types";
+/**
+ * Each rectangle is specified by the center point (mass center), length of each side (represented by
+ * [Size2f](#dc/d84/group__core__basic_1gab34496d2466b5f69930ab74c70f117d4}) structure) and the
+ * rotation angle in degrees.
+ *
+ * The sample below demonstrates how to use [RotatedRect](#db/dd6/classcv_1_1RotatedRect}):
+ *
+ * ```cpp
+ *     Mat test_image(200, 200, CV_8UC3, Scalar(0));
+ *     RotatedRect rRect = RotatedRect(Point2f(100,100), Size2f(100,50), 30);
+ *
+ *     Point2f vertices[4];
+ *     rRect.points(vertices);
+ *     for (int i = 0; i < 4; i++)
+ *         line(test_image, vertices[i], vertices[(i+1)%4], Scalar(0,255,0), 2);
+ *
+ *     Rect brect = rRect.boundingRect();
+ *     rectangle(test_image, brect, Scalar(255,0,0), 2);
+ *
+ *     imshow("rectangles", test_image);
+ *     waitKey(0);
+ * ```
+ *
+ * [CamShift](#dc/d6b/group__video__track_1gaef2bd39c8356f423124f1fe7c44d54a1}),
+ * [fitEllipse](#d3/dc0/group__imgproc__shape_1gaf259efaad93098103d6c27b9e4900ffa}),
+ * [minAreaRect](#d3/dc0/group__imgproc__shape_1ga3d476a3417130ae5154aea421ca7ead9}), CvBox2D
+ *
+ * Source:
+ * [opencv2/core/types.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/types.hpp#L534).
+ *
+ */
+export declare class RotatedRect {
+    angle: float;
+    center: Point2f;
+    size: Size2f;
+    constructor();
+    /**
+     *   full constructor
+     *
+     * @param center The rectangle mass center.
+     *
+     * @param size Width and height of the rectangle.
+     *
+     * @param angle The rotation angle in a clockwise direction. When the angle is 0, 90, 180, 270 etc.,
+     * the rectangle becomes an up-right rectangle.
+     */
+    constructor(center: Point2f, size: Size2f, angle: float);
+    /**
+     *   Any 3 end points of the [RotatedRect]. They must be given in order (either clockwise or
+     * anticlockwise).
+     */
+    constructor(point1: Point2f, point2: Point2f, point3: Point2f);
+    boundingRect(): Rect;
+    boundingRect2f(): Rect_;
+    /**
+     *   returns 4 vertices of the rectangle
+     *
+     * @param pts The points array for storing rectangle vertices. The order is bottomLeft, topLeft,
+     * topRight, bottomRight.
+     */
+    points(pts: Point2f): Point2f;
+}

package/dist/src/types/opencv/RotatedRect.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=RotatedRect.js.map

package/dist/src/types/opencv/RotatedRect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RotatedRect.js","sourceRoot":"","sources":["../../../../src/types/opencv/RotatedRect.ts"],"names":[],"mappings":""}