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

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

@@ -0,0 +1,270 @@
+export declare class Range {
+    start: number;
+    end: number;
+    constructor(start: number, end: number);
+}
+export declare class Scalar extends Array<number> {
+    static all(...v: number[]): Scalar;
+}
+export { Mat as InputArray };
+export { Mat as InputOutputArray };
+export { Mat as OutputArray };
+export { MatVector as InputArrayOfArrays };
+export { MatVector as InputOutputArrayOfArrays };
+export { MatVector as OutputArrayOfArrays };
+export { Scalar as GScalar };
+export { Point as Point2f };
+export { Point as KeyPoint };
+export { Point as Point2l };
+export { Size as Point2d };
+export { Size as Size2d };
+export { Size as Size2f };
+export { Size as Size2l };
+export { Rect as Rect_ };
+export declare class Point {
+    constructor(x: number, y: number);
+    x: number;
+    y: number;
+}
+export declare class Size {
+    constructor(width: number, height: number);
+    width: number;
+    height: number;
+}
+export declare class Rect {
+    constructor();
+    constructor(point: Point, size: Size);
+    constructor(x: number, y: number, width: number, height: number);
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class TermCriteria {
+    type: number;
+    maxCount: number;
+    epsilon: number;
+    constructor();
+    constructor(type: number, maxCount: number, epsilon: number);
+}
+export declare const TermCriteria_EPS: any;
+export declare const TermCriteria_COUNT: any;
+export declare const TermCriteria_MAX_ITER: any;
+export declare class MinMaxLoc {
+    minVal: number;
+    maxVal: number;
+    minLoc: Point;
+    maxLoc: Point;
+    constructor();
+    constructor(minVal: number, maxVal: number, minLoc: Point, maxLoc: Point);
+}
+export declare function exceptionFromPtr(err: number): any;
+export declare function onRuntimeInitialized(): any;
+export declare function FS_createDataFile(arg0: string, path: string, data: Uint8Array, arg3: boolean, arg4: boolean, arg5: boolean): any;
+import { Algorithm, LineTypes, Mat, NormTypes, RotatedRect } from ".";
+import "../_cv";
+/**
+ * Base class for Contrast Limited Adaptive Histogram Equalization.
+ */
+export declare class CLAHE extends Algorithm {
+    /**
+     * @param clipLimit Threshold for contrast limiting. Default.  40.0,
+     * @param totalGridSize Size of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column. Default: Size(8, 8)
+     */
+    constructor(clipLimit?: double, totalGridSize?: Size);
+    /**
+     * Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
+     * @param src Source image of type CV_8UC1 or CV_16UC1.
+     * @param dst Destination image.
+     */
+    apply(src: Mat, dst: Mat): void;
+    collectGarbage(): void;
+    /**
+     * Returns threshold value for contrast limiting.
+     */
+    getClipLimit(): double;
+    /**
+     * Returns Size defines the number of tiles in row and column.
+     */
+    getTilesGridSize(): Size;
+    /**
+     * Sets threshold for contrast limiting.
+     */
+    setClipLimit(clipLimit: double): void;
+    /**
+     * Sets size of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles.
+     * @param tileGridSize defines the number of tiles in row and column.
+     */
+    setTilesGridSize(tileGridSize: Size): void;
+}
+export declare function getInheritedInstanceCount(...a: any[]): any;
+export declare function getLiveInheritedInstances(...a: any[]): any;
+export declare function flushPendingDeletes(...a: any[]): any;
+export declare function setDelayFunction(...a: any[]): any;
+export declare class EmscriptenEmbindInstance {
+    isAliasOf(other: any): bool;
+    clone(): any;
+    delete(): any;
+    isDeleted(): boolean;
+    deleteLater(): any;
+}
+export declare class InternalError extends Error {
+}
+export declare class BindingError extends Error {
+}
+export declare class UnboundTypeError extends Error {
+}
+export declare class PureVirtualError extends Error {
+}
+export declare class Vector<T> extends EmscriptenEmbindInstance {
+    get(i: number): T;
+    get(i: number, j: number, data: any): T;
+    set(i: number, t: T): void;
+    put(i: number, j: number, data: any): any;
+    size(): number;
+    push_back(n: T): any;
+    resize(count: number, value?: T): void;
+}
+export declare class Vec3d extends Vector<any> {
+}
+export declare class IntVector extends Vector<number> {
+}
+export declare class FloatVector extends Vector<number> {
+}
+export declare class DoubleVector extends Vector<number> {
+}
+export declare class PointVector extends Vector<Point> {
+}
+export declare class KeyPointVector extends Vector<any> {
+}
+export declare class DMatchVector extends Vector<any> {
+}
+export declare class DMatchVectorVector extends Vector<Vector<any>> {
+}
+export declare class MatVector extends Vector<Mat> {
+}
+export declare class RectVector extends Rect implements Vector<Rect> {
+    get(i: number): Rect;
+    isAliasOf(...a: any[]): any;
+    clone(...a: any[]): any;
+    delete(...a: any[]): any;
+    isDeleted(...a: any[]): any;
+    deleteLater(...a: any[]): any;
+    set(i: number, t: Rect): void;
+    put(i: number, j: number, data: any): any;
+    size(): number;
+    push_back(n: Rect): void;
+    resize(count: number, value?: Rect | undefined): void;
+    delete(): void;
+}
+export declare class VideoCapture {
+    constructor(videoSource: HTMLVideoElement | string);
+    read(m: Mat): any;
+    video: HTMLVideoElement;
+}
+export type MatSize = () => Size;
+export declare function matFromImageData(imageData: ImageData): Mat;
+export declare function matFromArray(rows: number, cols: number, type: any, array: number[] | ArrayBufferView): Mat;
+export declare class ImageData {
+    data: ArrayBufferView;
+    width: number;
+    height: number;
+}
+export declare const CV_8U: CVDataType;
+export declare const CV_8UC1: CVDataType;
+export declare const CV_8UC2: CVDataType;
+export declare const CV_8UC3: CVDataType;
+export declare const CV_8UC4: CVDataType;
+export declare const CV_8S: CVDataType;
+export declare const CV_8SC1: CVDataType;
+export declare const CV_8SC2: CVDataType;
+export declare const CV_8SC3: CVDataType;
+export declare const CV_8SC4: CVDataType;
+export declare const CV_16U: CVDataType;
+export declare const CV_16UC1: CVDataType;
+export declare const CV_16UC2: CVDataType;
+export declare const CV_16UC3: CVDataType;
+export declare const CV_16UC4: CVDataType;
+export declare const CV_16S: CVDataType;
+export declare const CV_16SC1: CVDataType;
+export declare const CV_16SC2: CVDataType;
+export declare const CV_16SC3: CVDataType;
+export declare const CV_16SC4: CVDataType;
+export declare const CV_32S: CVDataType;
+export declare const CV_32SC1: CVDataType;
+export declare const CV_32SC2: CVDataType;
+export declare const CV_32SC3: CVDataType;
+export declare const CV_32SC4: CVDataType;
+export declare const CV_32F: CVDataType;
+export declare const CV_32FC1: CVDataType;
+export declare const CV_32FC2: CVDataType;
+export declare const CV_32FC3: CVDataType;
+export declare const CV_32FC4: CVDataType;
+export declare const CV_64F: CVDataType;
+export declare const CV_64FC1: CVDataType;
+export declare const CV_64FC2: CVDataType;
+export declare const CV_64FC3: CVDataType;
+export declare const CV_64FC4: CVDataType;
+export type CVDataType = any;
+export declare function ellipse1(dst: Mat, rotatedRect: RotatedRect, ellipseColor: Scalar, arg0: number, line: LineTypes): void;
+export declare function imread(canvasOrImageHtmlElement: HTMLElement | string): Mat;
+export declare function norm1(a: Mat, b: Mat, type: NormTypes): number;
+export declare function imshow(canvasSource: HTMLElement | string, mat: Mat): void;
+export declare function matFromArray(rows: number, cols: number, type: any, array: any): Mat;
+export type Mat4 = any;
+export type Mat3 = any;
+export type Vec3 = any;
+export type float_type = any;
+export type int = number;
+export type bool = boolean;
+export type FileNode = any;
+export type FileStorage = any;
+export type Ptr = any;
+export type size_t = any;
+export type double = number;
+export type float = number;
+export type UMat = any;
+export type Matrix = any;
+export type BucketKey = any;
+export type Bucket = any;
+export type LshStats = any;
+export type MatAllocator = any;
+export type uchar = any;
+export type MatStep = any;
+export type UMatData = any;
+export type typename = any;
+export type Vec = any;
+export type Point_ = any;
+export type Point3_ = any;
+export type MatCommaInitializer_ = any;
+export type MatIterator_ = any;
+export type MatConstIterator_ = any;
+export type AccessFlag = any;
+export type UMatUsageFlags = any;
+export type _Tp = any;
+export type Matx_AddOp = any;
+export type Matx_SubOp = any;
+export type _T2 = any;
+export type Matx_ScaleOp = any;
+export type Matx_MulOp = any;
+export type Matx_DivOp = any;
+export type Matx_MatMulOp = any;
+export type Matx_TOp = any;
+export type diag_type = any;
+export type _EqPredicate = any;
+export type cvhalDFT = any;
+export type schar = any;
+export type ushort = any;
+export type short = any;
+export type int64 = any;
+export type ErrorCallback = any;
+export type unsigned = any;
+export type uint64 = any;
+export type float16_t = any;
+export type AsyncArray = any;
+export type Net = any;
+export type Moments = any;
+export type uint64_t = any;
+export type uint32_t = any;
+export type int32_t = any;
+export type int64_t = any;

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

@@ -0,0 +1,10 @@
+"use strict";
+// Scalar, Point, Rect, etc are defined by opencv.js (helpers.js) and we need to declare them manually:
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rect_ = exports.Size2l = exports.Size2f = exports.Size2d = exports.Point2d = exports.Point2l = exports.KeyPoint = exports.Point2f = exports.GScalar = exports.OutputArrayOfArrays = exports.InputOutputArrayOfArrays = exports.InputArrayOfArrays = exports.OutputArray = exports.InputOutputArray = exports.InputArray = void 0;
+const _1 = require(".");
+Object.defineProperty(exports, "InputArray", { enumerable: true, get: function () { return _1.Mat; } });
+Object.defineProperty(exports, "InputOutputArray", { enumerable: true, get: function () { return _1.Mat; } });
+Object.defineProperty(exports, "OutputArray", { enumerable: true, get: function () { return _1.Mat; } });
+require("../_cv");
+//# sourceMappingURL=_hacks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_hacks.js","sourceRoot":"","sources":["../../../../src/types/opencv/_hacks.ts"],"names":[],"mappings":";AAAA,uGAAuG;;;AAwFvG,wBAAsE;AA5EtD,2FA4Ee,MAAG,OA5ER;AACV,iGA2Ee,MAAG,OA3EF;AAChB,4FA0Ee,MAAG,OA1EP;AA2E3B,kBAAgB"}

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

@@ -0,0 +1,44 @@
+export * from "./Affine3";
+export * from "./Algorithm";
+export * from "./AutoBuffer";
+export * from "./BFMatcher";
+export * from "./BOWTrainer";
+export * from "./calib3d";
+export * from "./CascadeClassifier";
+export * from "./core_array";
+export * from "./core_cluster";
+export * from "./core_hal_interface";
+export * from "./core_utils";
+export * from "./DescriptorMatcher";
+export * from "./dnn";
+export * from "./DynamicBitset";
+export * from "./Exception";
+export * from "./Feature2D";
+export * from "./features2d_draw";
+export * from "./FlannBasedMatcher";
+export * from "./HOGDescriptor";
+export * from "./imgproc_color_conversions";
+export * from "./imgproc_draw";
+export * from "./imgproc_feature";
+export * from "./imgproc_filter";
+export * from "./imgproc_hist";
+export * from "./imgproc_misc";
+export * from "./imgproc_object";
+export * from "./imgproc_shape";
+export * from "./imgproc_transform";
+export * from "./Logger";
+export * from "./LshTable";
+export * from "./Mat";
+export * from "./MatExpr";
+export * from "./MatOp";
+export * from "./Matx";
+export * from "./Node";
+export * from "./objdetect";
+export * from "./ORB";
+export * from "./PCA";
+export * from "./photo_inpaint";
+export * from "./RotatedRect";
+export * from "./softdouble";
+export * from "./softfloat";
+export * from "./video_track";
+export * from "./_hacks";

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

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Affine3"), exports);
+__exportStar(require("./Algorithm"), exports);
+__exportStar(require("./AutoBuffer"), exports);
+__exportStar(require("./BFMatcher"), exports);
+__exportStar(require("./BOWTrainer"), exports);
+__exportStar(require("./calib3d"), exports);
+__exportStar(require("./CascadeClassifier"), exports);
+__exportStar(require("./core_array"), exports);
+__exportStar(require("./core_cluster"), exports);
+__exportStar(require("./core_hal_interface"), exports);
+__exportStar(require("./core_utils"), exports);
+__exportStar(require("./DescriptorMatcher"), exports);
+__exportStar(require("./dnn"), exports);
+__exportStar(require("./DynamicBitset"), exports);
+__exportStar(require("./Exception"), exports);
+__exportStar(require("./Feature2D"), exports);
+__exportStar(require("./features2d_draw"), exports);
+__exportStar(require("./FlannBasedMatcher"), exports);
+__exportStar(require("./HOGDescriptor"), exports);
+__exportStar(require("./imgproc_color_conversions"), exports);
+__exportStar(require("./imgproc_draw"), exports);
+__exportStar(require("./imgproc_feature"), exports);
+__exportStar(require("./imgproc_filter"), exports);
+__exportStar(require("./imgproc_hist"), exports);
+__exportStar(require("./imgproc_misc"), exports);
+__exportStar(require("./imgproc_object"), exports);
+__exportStar(require("./imgproc_shape"), exports);
+__exportStar(require("./imgproc_transform"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./LshTable"), exports);
+__exportStar(require("./Mat"), exports);
+__exportStar(require("./MatExpr"), exports);
+__exportStar(require("./MatOp"), exports);
+__exportStar(require("./Matx"), exports);
+__exportStar(require("./Node"), exports);
+__exportStar(require("./objdetect"), exports);
+__exportStar(require("./ORB"), exports);
+__exportStar(require("./PCA"), exports);
+__exportStar(require("./photo_inpaint"), exports);
+__exportStar(require("./RotatedRect"), exports);
+__exportStar(require("./softdouble"), exports);
+__exportStar(require("./softfloat"), exports);
+__exportStar(require("./video_track"), exports);
+__exportStar(require("./_hacks"), exports);
+//# sourceMappingURL=_types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_types.js","sourceRoot":"","sources":["../../../../src/types/opencv/_types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,8CAA4B;AAC5B,+CAA6B;AAC7B,8CAA4B;AAC5B,+CAA6B;AAC7B,4CAA0B;AAC1B,sDAAoC;AACpC,+CAA6B;AAC7B,iDAA+B;AAC/B,uDAAqC;AACrC,+CAA6B;AAC7B,sDAAoC;AACpC,wCAAsB;AACtB,kDAAgC;AAChC,8CAA4B;AAC5B,8CAA4B;AAC5B,oDAAkC;AAClC,sDAAoC;AACpC,kDAAgC;AAChC,8DAA4C;AAC5C,iDAA+B;AAC/B,oDAAkC;AAClC,mDAAiC;AACjC,iDAA+B;AAC/B,iDAA+B;AAC/B,mDAAiC;AACjC,kDAAgC;AAChC,sDAAoC;AACpC,2CAAyB;AACzB,6CAA2B;AAC3B,wCAAsB;AACtB,4CAA0B;AAC1B,0CAAwB;AACxB,yCAAuB;AACvB,yCAAuB;AACvB,8CAA4B;AAC5B,wCAAsB;AACtB,wCAAsB;AACtB,kDAAgC;AAChC,gDAA8B;AAC9B,+CAA6B;AAC7B,8CAA4B;AAC5B,gDAA8B;AAC9B,2CAAyB"}