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

package/src/types/opencv/DescriptorMatcher.ts

@@ -0,0 +1,244 @@
+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.
+   */
+  public add(descriptors: InputArrayOfArrays): InputArrayOfArrays;
+
+  public 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.
+   */
+  public clone(emptyTrainData?: bool): Ptr;
+
+  public empty(): bool;
+
+  public getTrainDescriptors(): Mat;
+
+  public 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.
+   */
+  public 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.
+   */
+  public 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.
+   */
+  public 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].
+   */
+  public 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.
+   */
+  public 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.
+   */
+  public radiusMatch(
+    queryDescriptors: InputArray,
+    matches: any,
+    maxDistance: float,
+    masks?: InputArrayOfArrays,
+    compactResult?: bool,
+  ): InputArray;
+
+  public read(fileName: String): String;
+
+  public 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] ).
+   */
+  public train(): void;
+
+  public write(fileName: String): String;
+
+  public write(fs: FileStorage): FileStorage;
+
+  public 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
+   */
+  public static create(descriptorMatcherType: String): Ptr;
+
+  public static create(matcherType: any): Ptr;
+}
+
+export declare const FLANNBASED: MatcherType; // initializer: = 1
+
+export declare const BRUTEFORCE: MatcherType; // initializer: = 2
+
+export declare const BRUTEFORCE_L1: MatcherType; // initializer: = 3
+
+export declare const BRUTEFORCE_HAMMING: MatcherType; // initializer: = 4
+
+export declare const BRUTEFORCE_HAMMINGLUT: MatcherType; // initializer: = 5
+
+export declare const BRUTEFORCE_SL2: MatcherType; // initializer: = 6
+
+export type MatcherType = any;

package/src/types/opencv/DynamicBitset.ts

@@ -0,0 +1,68 @@
+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
+   */
+  public constructor();
+
+  /**
+   *   only constructor we use in our code
+   *
+   * @param sz the size of the bitset (in bits)
+   */
+  public constructor(sz: size_t);
+
+  /**
+   *   Sets all the bits to 0
+   */
+  public clear(): void;
+
+  /**
+   *   true if the bitset is empty
+   */
+  public empty(): bool;
+
+  /**
+   *   set all the bits to 0
+   */
+  public reset(): void;
+
+  public reset(index: size_t): void;
+
+  public reset_block(index: size_t): void;
+
+  /**
+   *   resize the bitset so that it contains at least sz bits
+   */
+  public resize(sz: size_t): void;
+
+  /**
+   *   set a bit to true
+   *
+   * @param index the index of the bit to set to 1
+   */
+  public set(index: size_t): void;
+
+  /**
+   *   gives the number of contained bits
+   */
+  public size(): size_t;
+
+  /**
+   *   check if a bit is set
+   *
+   *   true if the bit is set
+   *
+   * @param index the index of the bit to check
+   */
+  public test(index: size_t): bool;
+}

package/src/types/opencv/Exception.ts

@@ -0,0 +1,54 @@
+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
+   *
+   */
+  public code: int;
+
+  public err: String;
+
+  public file: String;
+
+  public func: String;
+
+  public line: int;
+
+  public msg: String;
+
+  /**
+   *   Default constructor
+   */
+  public constructor();
+
+  /**
+   *   Full constructor. Normally the constructor is not called explicitly. Instead, the macros
+   * [CV_Error()], [CV_Error_()] and [CV_Assert()] are used.
+   */
+  public constructor(
+    _code: int,
+    _err: String,
+    _func: String,
+    _file: String,
+    _line: int,
+  );
+
+  public formatMessage(): void;
+
+  /**
+   *   the error description and the context as a text string.
+   */
+  public what(): any;
+}

package/src/types/opencv/Feature2D.ts

@@ -0,0 +1,20 @@
+import { Algorithm, KeyPointVector, Mat, OutputArray } from "./_types";
+
+/**
+ * https://docs.opencv.org/4.8.0/d0/d13/classcv_1_1Feature2D.html
+ */
+export declare class Feature2D extends Algorithm {
+  /**
+   * Detects keypoints and computes the descriptors
+   * @param img
+   * @param mask
+   * @param keypoints
+   * @param descriptors
+   */
+  public detectAndCompute(
+    img: Mat,
+    mask: Mat,
+    keypoints: KeyPointVector,
+    descriptors: OutputArray,
+  ): void;
+}

package/src/types/opencv/FlannBasedMatcher.ts

@@ -0,0 +1,50 @@
+import { bool, FileNode, FileStorage, InputArrayOfArrays, Ptr } from "./_types";
+
+/**
+ * This matcher trains [cv::flann::Index](#d1/db2/classcv_1_1flann_1_1Index}) on a train descriptor
+ * collection and calls its nearest search methods to find the best matches. So, this matcher may be
+ * faster when matching a large train collection than the brute force matcher.
+ * [FlannBasedMatcher](#dc/de2/classcv_1_1FlannBasedMatcher}) does not support masking permissible
+ * matches of descriptor sets because [flann::Index](#d1/db2/classcv_1_1flann_1_1Index}) does not
+ * support this. :
+ *
+ * Source:
+ * [opencv2/features2d.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/features2d.hpp#L1187).
+ *
+ */
+export declare class FlannBasedMatcher {
+  public constructor(indexParams?: Ptr, searchParams?: Ptr);
+
+  /**
+   *   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.
+   */
+  public add(descriptors: InputArrayOfArrays): InputArrayOfArrays;
+
+  public 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.
+   */
+  public clone(emptyTrainData?: bool): Ptr;
+
+  public isMaskSupported(): bool;
+
+  public 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] ).
+   */
+  public train(): void;
+
+  public write(fs: FileStorage): FileStorage;
+
+  public static create(): Ptr;
+}