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

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

@@ -0,0 +1,105 @@
+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 {
+    constructor();
+    clear(): void;
+    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.
+     */
+    getDefaultName(): String;
+    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).
+     */
+    save(filename: String): String;
+    write(fs: FileStorage): FileStorage;
+    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)
+     */
+    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)
+     */
+    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)
+     */
+    static read(arg2: any, fn: FileNode): Ptr;
+}

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

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

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

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

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

@@ -0,0 +1,41 @@
+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 {
+    constructor();
+    constructor(_size: size_t);
+    constructor(buf: AutoBuffer);
+    allocate(_size: size_t): void;
+    data(): any;
+    data(): any;
+    deallocate(): void;
+    resize(_size: size_t): void;
+    size(): size_t;
+}

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

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

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

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

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

@@ -0,0 +1,33 @@
+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 {
+    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.
+     */
+    clone(emptyTrainData?: bool): Ptr;
+    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.
+     */
+    static create(normType?: int, crossCheck?: bool): Ptr;
+}

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

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

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

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

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

@@ -0,0 +1,36 @@
+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 {
+    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.
+     */
+    add(descriptors: Mat): Mat;
+    clear(): void;
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     */
+    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.
+     */
+    cluster(descriptors: Mat): Mat;
+    descriptorsCount(): int;
+    getDescriptors(): Mat;
+}

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

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

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

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

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

@@ -0,0 +1,100 @@
+import { bool, double, FileNode, InputArray, int, Mat, Ptr, Size } from "./_types";
+export declare class CascadeClassifier extends Mat {
+    cc: Ptr;
+    constructor();
+    /**
+     * @param filename Name of the file from which the classifier is loaded.
+     */
+    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.
+     */
+    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.
+     */
+    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;
+     *   ```
+     */
+    detectMultiScale(image: InputArray, objects: any, rejectLevels: any, levelWeights: any, scaleFactor?: double, minNeighbors?: int, flags?: int, minSize?: Size, maxSize?: Size, outputRejectLevels?: bool): InputArray;
+    empty(): bool;
+    getFeatureType(): int;
+    getMaskGenerator(): Ptr;
+    getOldCascade(): any;
+    getOriginalWindowSize(): Size;
+    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.
+     */
+    load(filename: String): String;
+    /**
+     *   The file may contain a new cascade classifier (trained traincascade application) only.
+     */
+    read(node: FileNode): FileNode;
+    setMaskGenerator(maskGenerator: Ptr): Ptr;
+    static convert(oldcascade: String, newcascade: String): String;
+}

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

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

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

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

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

@@ -0,0 +1,172 @@
+import { bool, FileNode, FileStorage, float, InputArray, InputArrayOfArrays, int, Mat, Ptr } from "./_types";
+/**
+ * It has two groups of match methods: for matching descriptors of an image with another image or with
+ * an image set.
+ *
+ * Source:
+ * [opencv2/features2d.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/features2d.hpp#L860).
+ *
+ */
+export declare class DescriptorMatcher {
+    /**
+     *   If the collection is not empty, the new descriptors are added to existing train descriptors.
+     *
+     * @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same
+     * train image.
+     */
+    add(descriptors: InputArrayOfArrays): InputArrayOfArrays;
+    clear(): void;
+    /**
+     * @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.
+     */
+    clone(emptyTrainData?: bool): Ptr;
+    empty(): bool;
+    getTrainDescriptors(): Mat;
+    isMaskSupported(): bool;
+    /**
+     *   These extended variants of [DescriptorMatcher::match] methods find several best matches for each
+     * query descriptor. The matches are returned in the distance increasing order. See
+     * [DescriptorMatcher::match] for the details about query and train descriptors.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+     * collection stored in the class object.
+     *
+     * @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
+     *
+     * @param k Count of best matches found per each query descriptor or less if a query descriptor has
+     * less than k possible matches in total.
+     *
+     * @param mask Mask specifying permissible matches between an input query and train matrices of
+     * descriptors.
+     *
+     * @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+     * false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the
+     * matches vector does not contain matches for fully masked-out query descriptors.
+     */
+    knnMatch(queryDescriptors: InputArray, trainDescriptors: InputArray, matches: any, k: int, mask?: InputArray, compactResult?: bool): InputArray;
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
+     *
+     * @param k Count of best matches found per each query descriptor or less if a query descriptor has
+     * less than k possible matches in total.
+     *
+     * @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+     * descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+     *
+     * @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+     * false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the
+     * matches vector does not contain matches for fully masked-out query descriptors.
+     */
+    knnMatch(queryDescriptors: InputArray, matches: any, k: int, masks?: InputArrayOfArrays, compactResult?: bool): InputArray;
+    /**
+     *   In the first variant of this method, the train descriptors are passed as an input argument. In the
+     * second variant of the method, train descriptors collection that was set by [DescriptorMatcher::add]
+     * is used. Optional mask (or masks) can be passed to specify which query and training descriptors can
+     * be matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if
+     * mask.at<uchar>(i,j) is non-zero.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+     * collection stored in the class object.
+     *
+     * @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
+     * descriptor. So, matches size may be smaller than the query descriptors count.
+     *
+     * @param mask Mask specifying permissible matches between an input query and train matrices of
+     * descriptors.
+     */
+    match(queryDescriptors: InputArray, trainDescriptors: InputArray, matches: any, mask?: InputArray): InputArray;
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
+     * descriptor. So, matches size may be smaller than the query descriptors count.
+     *
+     * @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+     * descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+     */
+    match(queryDescriptors: InputArray, matches: any, masks?: InputArrayOfArrays): InputArray;
+    /**
+     *   For each query descriptor, the methods find such training descriptors that the distance between
+     * the query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches
+     * are returned in the distance increasing order.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+     * collection stored in the class object.
+     *
+     * @param matches Found matches.
+     *
+     * @param maxDistance Threshold for the distance between matched descriptors. Distance means here
+     * metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured in
+     * Pixels)!
+     *
+     * @param mask Mask specifying permissible matches between an input query and train matrices of
+     * descriptors.
+     *
+     * @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+     * false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the
+     * matches vector does not contain matches for fully masked-out query descriptors.
+     */
+    radiusMatch(queryDescriptors: InputArray, trainDescriptors: InputArray, matches: any, maxDistance: float, mask?: InputArray, compactResult?: bool): InputArray;
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param queryDescriptors Query set of descriptors.
+     *
+     * @param matches Found matches.
+     *
+     * @param maxDistance Threshold for the distance between matched descriptors. Distance means here
+     * metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured in
+     * Pixels)!
+     *
+     * @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+     * descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+     *
+     * @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+     * false, the matches vector has the same size as queryDescriptors rows. If compactResult is true, the
+     * matches vector does not contain matches for fully masked-out query descriptors.
+     */
+    radiusMatch(queryDescriptors: InputArray, matches: any, maxDistance: float, masks?: InputArrayOfArrays, compactResult?: bool): InputArray;
+    read(fileName: String): String;
+    read(fn: FileNode): FileNode;
+    /**
+     *   Trains a descriptor matcher (for example, the flann index). In all methods to match, the method
+     * [train()] is run every time before matching. Some descriptor matchers (for example,
+     * BruteForceMatcher) have an empty implementation of this method. Other matchers really train their
+     * inner structures (for example, [FlannBasedMatcher] trains [flann::Index] ).
+     */
+    train(): void;
+    write(fileName: String): String;
+    write(fs: FileStorage): FileStorage;
+    write(fs: Ptr, name?: String): Ptr;
+    /**
+     * @param descriptorMatcherType Descriptor matcher type. Now the following matcher types are
+     * supported:
+     *   BruteForce (it uses L2 )BruteForce-L1BruteForce-HammingBruteForce-Hamming(2)FlannBased
+     */
+    static create(descriptorMatcherType: String): Ptr;
+    static create(matcherType: any): Ptr;
+}
+export declare const FLANNBASED: MatcherType;
+export declare const BRUTEFORCE: MatcherType;
+export declare const BRUTEFORCE_L1: MatcherType;
+export declare const BRUTEFORCE_HAMMING: MatcherType;
+export declare const BRUTEFORCE_HAMMINGLUT: MatcherType;
+export declare const BRUTEFORCE_SL2: MatcherType;
+export type MatcherType = any;

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

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

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

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

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

@@ -0,0 +1,57 @@
+import { bool, size_t } from "./_types";
+/**
+ * Class re-implementing the boost version of it This helps not depending on boost, it also does not do
+ * the bound checks and has a way to reset a block for speed
+ *
+ * Source:
+ * [opencv2/flann/dynamic_bitset.h](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/flann/dynamic_bitset.h#L150).
+ *
+ */
+export declare class DynamicBitset {
+    /**
+     *   default constructor
+     */
+    constructor();
+    /**
+     *   only constructor we use in our code
+     *
+     * @param sz the size of the bitset (in bits)
+     */
+    constructor(sz: size_t);
+    /**
+     *   Sets all the bits to 0
+     */
+    clear(): void;
+    /**
+     *   true if the bitset is empty
+     */
+    empty(): bool;
+    /**
+     *   set all the bits to 0
+     */
+    reset(): void;
+    reset(index: size_t): void;
+    reset_block(index: size_t): void;
+    /**
+     *   resize the bitset so that it contains at least sz bits
+     */
+    resize(sz: size_t): void;
+    /**
+     *   set a bit to true
+     *
+     * @param index the index of the bit to set to 1
+     */
+    set(index: size_t): void;
+    /**
+     *   gives the number of contained bits
+     */
+    size(): size_t;
+    /**
+     *   check if a bit is set
+     *
+     *   true if the bit is set
+     *
+     * @param index the index of the bit to check
+     */
+    test(index: size_t): bool;
+}

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { int } from "./_types";
+/**
+ * This class encapsulates all or almost all necessary information about the error happened in the
+ * program. The exception is usually constructed and thrown implicitly via CV_Error and CV_Error_
+ * macros.
+ *
+ * [error](#db/de0/group__core__utils_1gacbd081fdb20423a63cf731569ba70b2b})
+ *
+ * Source:
+ * [opencv2/core.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core.hpp#L135).
+ *
+ */
+export declare class Exception {
+    /**
+     *   CVStatus
+     *
+     */
+    code: int;
+    err: String;
+    file: String;
+    func: String;
+    line: int;
+    msg: String;
+    /**
+     *   Default constructor
+     */
+    constructor();
+    /**
+     *   Full constructor. Normally the constructor is not called explicitly. Instead, the macros
+     * [CV_Error()], [CV_Error_()] and [CV_Assert()] are used.
+     */
+    constructor(_code: int, _err: String, _func: String, _file: String, _line: int);
+    formatMessage(): void;
+    /**
+     *   the error description and the context as a text string.
+     */
+    what(): any;
+}

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

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

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

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