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

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;
+}

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

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

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

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

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

@@ -0,0 +1,67 @@
+import { Bucket, BucketKey, LshStats, Matrix, size_t } from "./_types";
+/**
+ * Lsh hash table. As its key is a sub-feature, and as usually the size of it is pretty small, we keep
+ * it as a continuous memory array. The value is an index in the corpus of features (we keep it as an
+ * unsigned int for pure memory reasons, it could be a size_t)
+ *
+ * Source:
+ * [opencv2/flann/lsh_table.h](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/flann/lsh_table.h#L261).
+ *
+ */
+export declare class LshTable {
+    /**
+     *   Default constructor
+     */
+    constructor();
+    /**
+     *   Default constructor Create the mask and allocate the memory
+     *
+     * @param feature_size is the size of the feature (considered as a ElementType[])
+     *
+     * @param key_size is the number of bits that are turned on in the feature
+     */
+    constructor(feature_size: any, key_size: any);
+    constructor(feature_size: any, subsignature_size: any);
+    /**
+     *   Add a feature to the table
+     *
+     * @param value the value to store for that feature
+     *
+     * @param feature the feature itself
+     */
+    add(value: any, feature: any): void;
+    /**
+     *   Add a set of features to the table
+     *
+     * @param dataset the values to store
+     */
+    add(dataset: Matrix): Matrix;
+    /**
+     *   Get a bucket given the key
+     */
+    getBucketFromKey(key: BucketKey): Bucket;
+    /**
+     *   Compute the sub-signature of a feature
+     */
+    getKey(arg50: any): size_t;
+    /**
+     *   Return the Subsignature of a feature
+     *
+     * @param feature the feature to analyze
+     */
+    getKey(feature: any): size_t;
+    /**
+     *   Get statistics about the table
+     */
+    getStats(): LshStats;
+    getStats(): LshStats;
+}
+export declare const kArray: SpeedLevel;
+export declare const kBitsetHash: SpeedLevel;
+export declare const kHash: SpeedLevel;
+/**
+ * defines the speed fo the implementation kArray uses a vector for storing data kBitsetHash uses a
+ * hash map but checks for the validity of a key with a bitset kHash uses a hash map only
+ *
+ */
+export type SpeedLevel = any;

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

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

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

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