@techstark/opencv-js 4.8.0-release.1 → 4.8.0-release.10

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":""}

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

@@ -0,0 +1,14 @@
+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
+     */
+    detectAndCompute(img: Mat, mask: Mat, keypoints: KeyPointVector, descriptors: OutputArray): void;
+}

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

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

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

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

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

@@ -0,0 +1,41 @@
+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 {
+    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.
+     */
+    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;
+    isMaskSupported(): bool;
+    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(fs: FileStorage): FileStorage;
+    static create(): Ptr;
+}

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

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

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

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

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

@@ -0,0 +1,265 @@
+import { bool, double, FileNode, FileStorage, float, InputArray, InputOutputArray, int, Point, Size, size_t, UMat } from "./_types";
+/**
+ * the HOG descriptor algorithm introduced by Navneet Dalal and Bill Triggs Dalal2005 .
+ *
+ * useful links:
+ *
+ * Source:
+ * [opencv2/objdetect.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/objdetect.hpp#L377).
+ *
+ */
+export declare class HOGDescriptor {
+    blockSize: Size;
+    blockStride: Size;
+    cellSize: Size;
+    derivAperture: int;
+    free_coef: float;
+    gammaCorrection: bool;
+    histogramNormType: any;
+    L2HysThreshold: double;
+    nbins: int;
+    nlevels: int;
+    oclSvmDetector: UMat;
+    signedGradient: bool;
+    svmDetector: any;
+    winSigma: double;
+    winSize: Size;
+    /**
+     *   aqual to [HOGDescriptor](Size(64,128), Size(16,16), Size(8,8), Size(8,8), 9 )
+     */
+    constructor();
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param _winSize sets winSize with given value.
+     *
+     * @param _blockSize sets blockSize with given value.
+     *
+     * @param _blockStride sets blockStride with given value.
+     *
+     * @param _cellSize sets cellSize with given value.
+     *
+     * @param _nbins sets nbins with given value.
+     *
+     * @param _derivAperture sets derivAperture with given value.
+     *
+     * @param _winSigma sets winSigma with given value.
+     *
+     * @param _histogramNormType sets histogramNormType with given value.
+     *
+     * @param _L2HysThreshold sets L2HysThreshold with given value.
+     *
+     * @param _gammaCorrection sets gammaCorrection with given value.
+     *
+     * @param _nlevels sets nlevels with given value.
+     *
+     * @param _signedGradient sets signedGradient with given value.
+     */
+    constructor(_winSize: Size, _blockSize: Size, _blockStride: Size, _cellSize: Size, _nbins: int, _derivAperture?: int, _winSigma?: double, _histogramNormType?: any, _L2HysThreshold?: double, _gammaCorrection?: bool, _nlevels?: int, _signedGradient?: bool);
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param filename The file name containing HOGDescriptor properties and coefficients for the linear
+     * SVM classifier.
+     */
+    constructor(filename: String);
+    /**
+     *   This is an overloaded member function, provided for convenience. It differs from the above
+     * function only in what argument(s) it accepts.
+     *
+     * @param d the HOGDescriptor which cloned to create a new one.
+     */
+    constructor(d: HOGDescriptor);
+    checkDetectorSize(): bool;
+    /**
+     * @param img Matrix of the type CV_8U containing an image where HOG features will be calculated.
+     *
+     * @param descriptors Matrix of the type CV_32F
+     *
+     * @param winStride Window stride. It must be a multiple of block stride.
+     *
+     * @param padding Padding
+     *
+     * @param locations Vector of Point
+     */
+    compute(img: InputArray, descriptors: any, winStride?: Size, padding?: Size, locations?: Point): InputArray;
+    /**
+     * @param img Matrix contains the image to be computed
+     *
+     * @param grad Matrix of type CV_32FC2 contains computed gradients
+     *
+     * @param angleOfs Matrix of type CV_8UC2 contains quantized gradient orientations
+     *
+     * @param paddingTL Padding from top-left
+     *
+     * @param paddingBR Padding from bottom-right
+     */
+    computeGradient(img: InputArray, grad: InputOutputArray, angleOfs: InputOutputArray, paddingTL?: Size, paddingBR?: Size): InputArray;
+    /**
+     * @param c cloned HOGDescriptor
+     */
+    copyTo(c: HOGDescriptor): HOGDescriptor;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param foundLocations Vector of point where each point contains left-top corner point of detected
+     * object boundaries.
+     *
+     * @param weights Vector that will contain confidence values for each detected object.
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here.
+     *
+     * @param winStride Window stride. It must be a multiple of block stride.
+     *
+     * @param padding Padding
+     *
+     * @param searchLocations Vector of Point includes set of requested locations to be evaluated.
+     */
+    detect(img: InputArray, foundLocations: any, weights: any, hitThreshold?: double, winStride?: Size, padding?: Size, searchLocations?: Point): InputArray;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param foundLocations Vector of point where each point contains left-top corner point of detected
+     * object boundaries.
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here.
+     *
+     * @param winStride Window stride. It must be a multiple of block stride.
+     *
+     * @param padding Padding
+     *
+     * @param searchLocations Vector of Point includes locations to search.
+     */
+    detect(img: InputArray, foundLocations: any, hitThreshold?: double, winStride?: Size, padding?: Size, searchLocations?: Point): InputArray;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+     *
+     * @param foundWeights Vector that will contain confidence values for each detected object.
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here.
+     *
+     * @param winStride Window stride. It must be a multiple of block stride.
+     *
+     * @param padding Padding
+     *
+     * @param scale Coefficient of the detection window increase.
+     *
+     * @param finalThreshold Final threshold
+     *
+     * @param useMeanshiftGrouping indicates grouping algorithm
+     */
+    detectMultiScale(img: InputArray, foundLocations: any, foundWeights: any, hitThreshold?: double, winStride?: Size, padding?: Size, scale?: double, finalThreshold?: double, useMeanshiftGrouping?: bool): InputArray;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here.
+     *
+     * @param winStride Window stride. It must be a multiple of block stride.
+     *
+     * @param padding Padding
+     *
+     * @param scale Coefficient of the detection window increase.
+     *
+     * @param finalThreshold Final threshold
+     *
+     * @param useMeanshiftGrouping indicates grouping algorithm
+     */
+    detectMultiScale(img: InputArray, foundLocations: any, hitThreshold?: double, winStride?: Size, padding?: Size, scale?: double, finalThreshold?: double, useMeanshiftGrouping?: bool): InputArray;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+     *
+     * @param locations Vector of DetectionROI
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here.
+     *
+     * @param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a
+     * group of rectangles to retain it.
+     */
+    detectMultiScaleROI(img: InputArray, foundLocations: any, locations: any, hitThreshold?: double, groupThreshold?: int): InputArray;
+    /**
+     * @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+     *
+     * @param locations Vector of Point
+     *
+     * @param foundLocations Vector of Point where each Point is detected object's top-left point.
+     *
+     * @param confidences confidences
+     *
+     * @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+     * it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+     * the free coefficient is omitted (which is allowed), you can specify it manually here
+     *
+     * @param winStride winStride
+     *
+     * @param padding padding
+     */
+    detectROI(img: InputArray, locations: any, foundLocations: any, confidences: any, hitThreshold?: double, winStride?: any, padding?: any): InputArray;
+    getDescriptorSize(): size_t;
+    getWinSigma(): double;
+    /**
+     * @param rectList Input/output vector of rectangles. Output vector includes retained and grouped
+     * rectangles. (The Python list is not modified in place.)
+     *
+     * @param weights Input/output vector of weights of rectangles. Output vector includes weights of
+     * retained and grouped rectangles. (The Python list is not modified in place.)
+     *
+     * @param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a
+     * group of rectangles to retain it.
+     *
+     * @param eps Relative difference between sides of the rectangles to merge them into a group.
+     */
+    groupRectangles(rectList: any, weights: any, groupThreshold: int, eps: double): any;
+    /**
+     * @param filename Path 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).
+     */
+    load(filename: String, objname?: String): String;
+    /**
+     * @param fn File node
+     */
+    read(fn: FileNode): FileNode;
+    /**
+     * @param filename File name
+     *
+     * @param objname Object name
+     */
+    save(filename: String, objname?: String): String;
+    /**
+     * @param svmdetector coefficients for the linear SVM classifier.
+     */
+    setSVMDetector(svmdetector: InputArray): InputArray;
+    /**
+     * @param fs File storage
+     *
+     * @param objname Object name
+     */
+    write(fs: FileStorage, objname: String): FileStorage;
+    static getDaimlerPeopleDetector(): any;
+    static getDefaultPeopleDetector(): any;
+}
+export declare const DEFAULT_NLEVELS: any;
+export declare const DESCR_FORMAT_COL_BY_COL: DescriptorStorageFormat;
+export declare const DESCR_FORMAT_ROW_BY_ROW: DescriptorStorageFormat;
+export declare const L2Hys: HistogramNormType;
+export type DescriptorStorageFormat = any;
+export type HistogramNormType = any;

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { int } from "./_types";
+export declare class Logger {
+    static error(fmt: any, arg121: any): int;
+    static fatal(fmt: any, arg122: any): int;
+    static info(fmt: any, arg123: any): int;
+    /**
+     *   Print log message
+     *
+     * @param level Log level
+     *
+     * @param fmt Message format
+     */
+    static log(level: int, fmt: any, arg124: any): int;
+    /**
+     *   Sets the logging destination
+     *
+     * @param name Filename or NULL for console
+     */
+    static setDestination(name: any): void;
+    /**
+     *   Sets the logging level. All messages with lower priority will be ignored.
+     *
+     * @param level Logging level
+     */
+    static setLevel(level: int): void;
+    static warn(fmt: any, arg125: any): int;
+}