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

package/src/types/opencv/Affine3.ts

@@ -0,0 +1,206 @@
+import { float_type, int, Mat, Mat3, Mat4, Vec3 } from "./_types";
+
+/**
+ * It represents a 4x4 homogeneous transformation matrix `$T$`
+ *
+ * `\\[T = \\begin{bmatrix} R & t\\\\ 0 & 1\\\\ \\end{bmatrix} \\]`
+ *
+ * where `$R$` is a 3x3 rotation matrix and `$t$` is a 3x1 translation vector.
+ *
+ * You can specify `$R$` either by a 3x3 rotation matrix or by a 3x1 rotation vector, which is
+ * converted to a 3x3 rotation matrix by the Rodrigues formula.
+ *
+ * To construct a matrix `$T$` representing first rotation around the axis `$r$` with rotation angle
+ * `$|r|$` in radian (right hand rule) and then translation by the vector `$t$`, you can use
+ *
+ * ```cpp
+ * cv::Vec3f r, t;
+ * cv::Affine3f T(r, t);
+ * ```
+ *
+ * If you already have the rotation matrix `$R$`, then you can use
+ *
+ * ```cpp
+ * cv::Matx33f R;
+ * cv::Affine3f T(R, t);
+ * ```
+ *
+ * To extract the rotation matrix `$R$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Matx33f R = T.rotation();
+ * ```
+ *
+ * To extract the translation vector `$t$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Vec3f t = T.translation();
+ * ```
+ *
+ * To extract the rotation vector `$r$` from `$T$`, use
+ *
+ * ```cpp
+ * cv::Vec3f r = T.rvec();
+ * ```
+ *
+ * Note that since the mapping from rotation vectors to rotation matrices is many to one. The returned
+ * rotation vector is not necessarily the one you used before to set the matrix.
+ *
+ * If you have two transformations `$T = T_1 * T_2$`, use
+ *
+ * ```cpp
+ * cv::Affine3f T, T1, T2;
+ * T = T2.concatenate(T1);
+ * ```
+ *
+ * To get the inverse transform of `$T$`, use
+ *
+ * ```cpp
+ * cv::Affine3f T, T_inv;
+ * T_inv = T.inv();
+ * ```
+ *
+ * Source:
+ * [opencv2/core/affine.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/affine.hpp#L129).
+ *
+ */
+export declare class Affine3 {
+  public matrix: Mat4;
+
+  public constructor();
+
+  public constructor(affine: Mat4);
+
+  /**
+   *   The resulting 4x4 matrix is
+   *
+   *   `\\[ \\begin{bmatrix} R & t\\\\ 0 & 1\\\\ \\end{bmatrix} \\]`
+   *
+   * @param R 3x3 rotation matrix.
+   *
+   * @param t 3x1 translation vector.
+   */
+  public constructor(R: Mat3, t?: Vec3);
+
+  /**
+   *   Rodrigues vector.
+   *
+   *   The last row of the current matrix is set to [0,0,0,1].
+   *
+   * @param rvec 3x1 rotation vector. Its direction indicates the rotation axis and its length
+   * indicates the rotation angle in radian (using right hand rule).
+   *
+   * @param t 3x1 translation vector.
+   */
+  public constructor(rvec: Vec3, t?: Vec3);
+
+  /**
+   *   Combines all constructors above. Supports 4x4, 3x4, 3x3, 1x3, 3x1 sizes of data matrix.
+   *
+   *   The last row of the current matrix is set to [0,0,0,1] when data is not 4x4.
+   *
+   * @param data 1-channel matrix. when it is 4x4, it is copied to the current matrix and t is not
+   * used. When it is 3x4, it is copied to the upper part 3x4 of the current matrix and t is not used.
+   * When it is 3x3, it is copied to the upper left 3x3 part of the current matrix. When it is 3x1 or
+   * 1x3, it is treated as a rotation vector and the Rodrigues formula is used to compute a 3x3 rotation
+   * matrix.
+   *
+   * @param t 3x1 translation vector. It is used only when data is neither 4x4 nor 3x4.
+   */
+  public constructor(data: Mat, t?: Vec3);
+
+  public constructor(vals: float_type);
+
+  public cast(arg401: any): Affine3;
+
+  public concatenate(affine: Affine3): Affine3;
+
+  /**
+   *   the inverse of the current matrix.
+   */
+  public inv(method?: int): Affine3;
+
+  /**
+   *   Copy the 3x3 matrix L to the upper left part of the current matrix
+   *
+   *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+   *
+   * @param L 3x3 matrix.
+   */
+  public linear(L: Mat3): Mat3;
+
+  /**
+   *   the upper left 3x3 part
+   */
+  public linear(): Mat3;
+
+  public rotate(R: Mat3): Affine3;
+
+  public rotate(rvec: Vec3): Affine3;
+
+  /**
+   *   Rotation matrix.
+   *
+   *   Copy the rotation matrix to the upper left 3x3 part of the current matrix. The remaining elements
+   * of the current matrix are not changed.
+   *
+   * @param R 3x3 rotation matrix.
+   */
+  public rotation(R: Mat3): Mat3;
+
+  /**
+   *   Rodrigues vector.
+   *
+   *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+   *
+   * @param rvec 3x1 rotation vector. The direction indicates the rotation axis and its length
+   * indicates the rotation angle in radian (using the right thumb convention).
+   */
+  public rotation(rvec: Vec3): Vec3;
+
+  /**
+   *   Combines rotation methods above. Supports 3x3, 1x3, 3x1 sizes of data matrix.
+   *
+   *   It sets the upper left 3x3 part of the matrix. The remaining part is unaffected.
+   *
+   * @param data 1-channel matrix. When it is a 3x3 matrix, it sets the upper left 3x3 part of the
+   * current matrix. When it is a 1x3 or 3x1 matrix, it is used as a rotation vector. The Rodrigues
+   * formula is used to compute the rotation matrix and sets the upper left 3x3 part of the current
+   * matrix.
+   */
+  public rotation(data: Mat): Mat;
+
+  /**
+   *   the upper left 3x3 part
+   */
+  public rotation(): Mat3;
+
+  /**
+   *   Rodrigues vector.
+   *
+   *   a vector representing the upper left 3x3 rotation matrix of the current matrix.
+   *
+   *   Since the mapping between rotation vectors and rotation matrices is many to one, this function
+   * returns only one rotation vector that represents the current rotation matrix, which is not
+   * necessarily the same one set by `[rotation(const Vec3& rvec)]`.
+   */
+  public rvec(): Vec3;
+
+  public translate(t: Vec3): Affine3;
+
+  /**
+   *   Copy t to the first three elements of the last column of the current matrix
+   *
+   *   It sets the upper right 3x1 part of the matrix. The remaining part is unaffected.
+   *
+   * @param t 3x1 translation vector.
+   */
+  public translation(t: Vec3): Vec3;
+
+  /**
+   *   the upper right 3x1 part
+   */
+  public translation(): Vec3;
+
+  public static Identity(): Affine3;
+}

package/src/types/opencv/Algorithm.ts

@@ -0,0 +1,126 @@
+import {
+  bool,
+  EmscriptenEmbindInstance,
+  FileNode,
+  FileStorage,
+  Ptr,
+} from "./_types";
+
+/**
+ * especially for classes of algorithms, for which there can be multiple implementations. The examples
+ * are stereo correspondence (for which there are algorithms like block matching, semi-global block
+ * matching, graph-cut etc.), background subtraction (which can be done using mixture-of-gaussians
+ * models, codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade, Horn-Schunck
+ * etc.).
+ *
+ * Here is example of [SimpleBlobDetector](#d0/d7a/classcv_1_1SimpleBlobDetector}) use in your
+ * application via [Algorithm](#d3/d46/classcv_1_1Algorithm}) interface:
+ *
+ * ```cpp
+ *     Ptr<Feature2D> sbd = SimpleBlobDetector::create();
+ *     FileStorage fs_read("SimpleBlobDetector_params.xml", FileStorage::READ);
+ *
+ *     if (fs_read.isOpened()) // if we have file with parameters, read them
+ *     {
+ *         sbd->read(fs_read.root());
+ *         fs_read.release();
+ *     }
+ *     else // else modify the parameters and store them; user can later edit the file to use different
+ * parameters
+ *     {
+ *         fs_read.release();
+ *         FileStorage fs_write("SimpleBlobDetector_params.xml", FileStorage::WRITE);
+ *         sbd->write(fs_write);
+ *         fs_write.release();
+ *     }
+ *
+ *     Mat result, image = imread("../data/detect_blob.png", IMREAD_COLOR);
+ *     vector<KeyPoint> keypoints;
+ *     sbd->detect(image, keypoints, Mat());
+ *
+ *     drawKeypoints(image, keypoints, result);
+ *     for (vector<KeyPoint>::iterator k = keypoints.begin(); k != keypoints.end(); ++k)
+ *         circle(result, k->pt, (int)k->size, Scalar(0, 0, 255), 2);
+ *
+ *     imshow("result", result);
+ *     waitKey(0);
+ * ```
+ *
+ * Source:
+ * [opencv2/core.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core.hpp#L3077).
+ *
+ */
+export declare class Algorithm extends EmscriptenEmbindInstance {
+  public constructor();
+
+  public clear(): void;
+
+  public empty(): bool;
+
+  /**
+   *   Returns the algorithm string identifier. This string is used as top level xml/yml node tag when
+   * the object is saved to a file or string.
+   */
+  public getDefaultName(): String;
+
+  public read(fn: FileNode): FileNode;
+
+  /**
+   *   Saves the algorithm to a file. In order to make this method work, the derived class must implement
+   * Algorithm::write(FileStorage& fs).
+   */
+  public save(filename: String): String;
+
+  public write(fs: FileStorage): FileStorage;
+
+  public write(fs: Ptr, name?: String): Ptr;
+
+  /**
+   *   This is static template method of [Algorithm]. It's usage is following (in the case of SVM):
+   *
+   *   ```cpp
+   *   Ptr<SVM> svm = Algorithm::load<SVM>("my_svm_model.xml");
+   *   ```
+   *
+   *    In order to make this method work, the derived class must overwrite [Algorithm::read](const
+   * [FileNode]& fn).
+   *
+   * @param filename Name of the file to read.
+   *
+   * @param objname The optional name of the node to read (if empty, the first top-level node will be
+   * used)
+   */
+  public static load(arg0: any, filename: String, objname?: String): Ptr;
+
+  /**
+   *   This is static template method of [Algorithm]. It's usage is following (in the case of SVM):
+   *
+   *   ```cpp
+   *   Ptr<SVM> svm = Algorithm::loadFromString<SVM>(myStringModel);
+   *   ```
+   *
+   * @param strModel The string variable containing the model you want to load.
+   *
+   * @param objname The optional name of the node to read (if empty, the first top-level node will be
+   * used)
+   */
+  public static loadFromString(
+    arg1: any,
+    strModel: String,
+    objname?: String,
+  ): Ptr;
+
+  /**
+   *   This is static template method of [Algorithm]. It's usage is following (in the case of SVM):
+   *
+   *   ```cpp
+   *   cv::FileStorage fsRead("example.xml", FileStorage::READ);
+   *   Ptr<SVM> svm = Algorithm::read<SVM>(fsRead.root());
+   *   ```
+   *
+   *    In order to make this method work, the derived class must overwrite [Algorithm::read](const
+   * [FileNode]& fn) and also have static create() method without parameters (or with all the optional
+   * parameters)
+   */
+  public static read(arg2: any, fn: FileNode): Ptr;
+}

package/src/types/opencv/AutoBuffer.ts

@@ -0,0 +1,50 @@
+import { size_t } from "./_types";
+
+/**
+ * The class is used for temporary buffers in functions and methods. If a temporary buffer is usually
+ * small (a few K's of memory), but its size depends on the parameters, it makes sense to create a
+ * small fixed-size array on stack and use it if it's large enough. If the required buffer size is
+ * larger than the fixed size, another buffer of sufficient size is allocated dynamically and released
+ * after the processing. Therefore, in typical cases, when the buffer size is small, there is no
+ * overhead associated with malloc()/free(). At the same time, there is no limit on the size of
+ * processed data.
+ *
+ * This is what [AutoBuffer](#d8/dd0/classcv_1_1AutoBuffer}) does. The template takes 2 parameters -
+ * type of the buffer elements and the number of stack-allocated elements. Here is how the class is
+ * used:
+ *
+ * ```cpp
+ * void my_func(const cv::Mat& m)
+ * {
+ *    cv::AutoBuffer<float> buf(1000); // create automatic buffer containing 1000 floats
+ *
+ *    buf.allocate(m.rows); // if m.rows <= 1000, the pre-allocated buffer is used,
+ *                          // otherwise the buffer of "m.rows" floats will be allocated
+ *                          // dynamically and deallocated in cv::AutoBuffer destructor
+ *    ...
+ * }
+ * ```
+ *
+ * Source:
+ * [opencv2/core/utility.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/utility.hpp#L128).
+ *
+ */
+export declare class AutoBuffer {
+  public constructor();
+
+  public constructor(_size: size_t);
+
+  public constructor(buf: AutoBuffer);
+
+  public allocate(_size: size_t): void;
+
+  public data(): any;
+
+  public data(): any;
+
+  public deallocate(): void;
+
+  public resize(_size: size_t): void;
+
+  public size(): size_t;
+}

package/src/types/opencv/BFMatcher.ts

@@ -0,0 +1,37 @@
+import { bool, int, Ptr } from "./_types";
+
+/**
+ * For each descriptor in the first set, this matcher finds the closest descriptor in the second set by
+ * trying each one. This descriptor matcher supports masking permissible matches of descriptor sets.
+ *
+ * Source:
+ * [opencv2/features2d.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/features2d.hpp#L1140).
+ *
+ */
+export declare class BFMatcher {
+  public constructor(normType?: int, crossCheck?: bool);
+
+  /**
+   * @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,
+   * that is, copies both parameters and train data. If emptyTrainData is true, the method creates an
+   * object copy with the current parameters but with empty train data.
+   */
+  public clone(emptyTrainData?: bool): Ptr;
+
+  public isMaskSupported(): bool;
+
+  /**
+   * @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and L2 norms are
+   * preferable choices for SIFT and SURF descriptors, NORM_HAMMING should be used with ORB, BRISK and
+   * BRIEF, NORM_HAMMING2 should be used with ORB when WTA_K==3 or 4 (see ORB::ORB constructor
+   * description).
+   *
+   * @param crossCheck If it is false, this is will be default BFMatcher behaviour when it finds the k
+   * nearest neighbors for each query descriptor. If crossCheck==true, then the knnMatch() method with
+   * k=1 will only return pairs (i,j) such that for i-th query descriptor the j-th descriptor in the
+   * matcher's collection is the nearest and vice versa, i.e. the BFMatcher will only return consistent
+   * pairs. Such technique usually produces best results with minimal number of outliers when there are
+   * enough matches. This is alternative to the ratio test, used by D. Lowe in SIFT paper.
+   */
+  public static create(normType?: int, crossCheck?: bool): Ptr;
+}

package/src/types/opencv/BOWTrainer.ts

@@ -0,0 +1,43 @@
+import { int, Mat } from "./_types";
+
+/**
+ * For details, see, for example, *Visual Categorization with Bags of Keypoints* by Gabriella Csurka,
+ * Christopher R. Dance, Lixin Fan, Jutta Willamowski, Cedric Bray, 2004. :
+ *
+ * Source:
+ * [opencv2/features2d.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/features2d.hpp#L1339).
+ *
+ */
+export declare class BOWTrainer {
+  public constructor();
+
+  /**
+   *   The training set is clustered using clustermethod to construct the vocabulary.
+   *
+   * @param descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a
+   * descriptor.
+   */
+  public add(descriptors: Mat): Mat;
+
+  public clear(): void;
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   */
+  public cluster(): Mat;
+
+  /**
+   *   The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first
+   * variant of the method, train descriptors stored in the object are clustered. In the second variant,
+   * input descriptors are clustered.
+   *
+   * @param descriptors Descriptors to cluster. Each row of the descriptors matrix is a descriptor.
+   * Descriptors are not added to the inner train descriptor set.
+   */
+  public cluster(descriptors: Mat): Mat;
+
+  public descriptorsCount(): int;
+
+  public getDescriptors(): Mat;
+}

package/src/types/opencv/CascadeClassifier.ts

@@ -0,0 +1,153 @@
+import {
+  bool,
+  double,
+  FileNode,
+  InputArray,
+  int,
+  Mat,
+  Ptr,
+  Size,
+} from "./_types";
+
+export declare class CascadeClassifier extends Mat {
+  public cc: Ptr;
+
+  public constructor();
+
+  /**
+   * @param filename Name of the file from which the classifier is loaded.
+   */
+  public constructor(filename: String);
+
+  /**
+   *   The function is parallelized with the TBB library.
+   *
+   * (Python) A face detection example using cascade classifiers can be found at
+   * opencv_source_code/samples/python/facedetect.py
+   *
+   * @param image Matrix of the type CV_8U containing an image where objects are detected.
+   *
+   * @param objects Vector of rectangles where each rectangle contains the detected object, the
+   * rectangles may be partially outside the original image.
+   *
+   * @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+   *
+   * @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+   * to retain it.
+   *
+   * @param flags Parameter with the same meaning for an old cascade as in the function
+   * cvHaarDetectObjects. It is not used for a new cascade.
+   *
+   * @param minSize Minimum possible object size. Objects smaller than that are ignored.
+   *
+   * @param maxSize Maximum possible object size. Objects larger than that are ignored. If maxSize ==
+   * minSize model is evaluated on single scale.
+   */
+  public detectMultiScale(
+    image: InputArray,
+    objects: any,
+    scaleFactor?: double,
+    minNeighbors?: int,
+    flags?: int,
+    minSize?: Size,
+    maxSize?: Size,
+  ): InputArray;
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts.
+   *
+   * @param image Matrix of the type CV_8U containing an image where objects are detected.
+   *
+   * @param objects Vector of rectangles where each rectangle contains the detected object, the
+   * rectangles may be partially outside the original image.
+   *
+   * @param numDetections Vector of detection numbers for the corresponding objects. An object's number
+   * of detections is the number of neighboring positively classified rectangles that were joined
+   * together to form the object.
+   *
+   * @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+   *
+   * @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+   * to retain it.
+   *
+   * @param flags Parameter with the same meaning for an old cascade as in the function
+   * cvHaarDetectObjects. It is not used for a new cascade.
+   *
+   * @param minSize Minimum possible object size. Objects smaller than that are ignored.
+   *
+   * @param maxSize Maximum possible object size. Objects larger than that are ignored. If maxSize ==
+   * minSize model is evaluated on single scale.
+   */
+  public detectMultiScale(
+    image: InputArray,
+    objects: any,
+    numDetections: any,
+    scaleFactor?: double,
+    minNeighbors?: int,
+    flags?: int,
+    minSize?: Size,
+    maxSize?: Size,
+  ): InputArray;
+
+  /**
+   *   This is an overloaded member function, provided for convenience. It differs from the above
+   * function only in what argument(s) it accepts. This function allows you to retrieve the final stage
+   * decision certainty of classification. For this, one needs to set `outputRejectLevels` on true and
+   * provide the `rejectLevels` and `levelWeights` parameter. For each resulting detection,
+   * `levelWeights` will then contain the certainty of classification at the final stage. This value can
+   * then be used to separate strong from weaker classifications.
+   *
+   *   A code sample on how to use it efficiently can be found below:
+   *
+   *   ```cpp
+   *   Mat img;
+   *   vector<double> weights;
+   *   vector<int> levels;
+   *   vector<Rect> detections;
+   *   CascadeClassifier model("/path/to/your/model.xml");
+   *   model.detectMultiScale(img, detections, levels, weights, 1.1, 3, 0, Size(), Size(), true);
+   *   cerr << "Detection " << detections[0] << " with weight " << weights[0] << endl;
+   *   ```
+   */
+  public detectMultiScale(
+    image: InputArray,
+    objects: any,
+    rejectLevels: any,
+    levelWeights: any,
+    scaleFactor?: double,
+    minNeighbors?: int,
+    flags?: int,
+    minSize?: Size,
+    maxSize?: Size,
+    outputRejectLevels?: bool,
+  ): InputArray;
+
+  public empty(): bool;
+
+  public getFeatureType(): int;
+
+  public getMaskGenerator(): Ptr;
+
+  public getOldCascade(): any;
+
+  public getOriginalWindowSize(): Size;
+
+  public isOldFormatCascade(): bool;
+
+  /**
+   * @param filename Name of the file from which the classifier is loaded. The file may contain an old
+   * HAAR classifier trained by the haartraining application or a new cascade classifier trained by the
+   * traincascade application.
+   */
+  public load(filename: String): String;
+
+  /**
+   *   The file may contain a new cascade classifier (trained traincascade application) only.
+   */
+  public read(node: FileNode): FileNode;
+
+  public setMaskGenerator(maskGenerator: Ptr): Ptr;
+
+  public static convert(oldcascade: String, newcascade: String): String;
+}