@opencvjs/types 4.10.0-release.1

package/lib/opencv/BOWTrainer.d.ts

@@ -0,0 +1,43 @@
+import type { 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/lib/opencv/CascadeClassifier.d.ts

@@ -0,0 +1,153 @@
+import type {
+  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;
+}

package/lib/opencv/DescriptorMatcher.d.ts

@@ -0,0 +1,236 @@
+import type {
+  Algorithm,
+  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 extends Algorithm {
+  /**
+   *   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;
+}
+
+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/lib/opencv/DynamicBitset.d.ts

@@ -0,0 +1,68 @@
+import type { 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/lib/opencv/Exception.d.ts

@@ -0,0 +1,54 @@
+import type { 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/lib/opencv/Feature2D.d.ts

@@ -0,0 +1,20 @@
+import type { Algorithm, KeyPointVector, Mat, OutputArray } from "./_types";
+
+/**
+ * https://docs.opencv.org/4.10.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/lib/opencv/FlannBasedMatcher.d.ts

@@ -0,0 +1,57 @@
+import type {
+  bool,
+  DescriptorMatcher,
+  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 extends DescriptorMatcher {
+  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;
+}