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

package/src/types/opencv/RotatedRect.ts

@@ -0,0 +1,72 @@
+import { float, Point2f, Rect, Rect_, Size2f } from "./_types";
+
+/**
+ * Each rectangle is specified by the center point (mass center), length of each side (represented by
+ * [Size2f](#dc/d84/group__core__basic_1gab34496d2466b5f69930ab74c70f117d4}) structure) and the
+ * rotation angle in degrees.
+ *
+ * The sample below demonstrates how to use [RotatedRect](#db/dd6/classcv_1_1RotatedRect}):
+ *
+ * ```cpp
+ *     Mat test_image(200, 200, CV_8UC3, Scalar(0));
+ *     RotatedRect rRect = RotatedRect(Point2f(100,100), Size2f(100,50), 30);
+ *
+ *     Point2f vertices[4];
+ *     rRect.points(vertices);
+ *     for (int i = 0; i < 4; i++)
+ *         line(test_image, vertices[i], vertices[(i+1)%4], Scalar(0,255,0), 2);
+ *
+ *     Rect brect = rRect.boundingRect();
+ *     rectangle(test_image, brect, Scalar(255,0,0), 2);
+ *
+ *     imshow("rectangles", test_image);
+ *     waitKey(0);
+ * ```
+ *
+ * [CamShift](#dc/d6b/group__video__track_1gaef2bd39c8356f423124f1fe7c44d54a1}),
+ * [fitEllipse](#d3/dc0/group__imgproc__shape_1gaf259efaad93098103d6c27b9e4900ffa}),
+ * [minAreaRect](#d3/dc0/group__imgproc__shape_1ga3d476a3417130ae5154aea421ca7ead9}), CvBox2D
+ *
+ * Source:
+ * [opencv2/core/types.hpp](https://github.com/opencv/opencv/tree/master/modules/core/include/opencv2/core/types.hpp#L534).
+ *
+ */
+export declare class RotatedRect {
+  public angle: float;
+
+  public center: Point2f;
+
+  public size: Size2f;
+
+  public constructor();
+
+  /**
+   *   full constructor
+   *
+   * @param center The rectangle mass center.
+   *
+   * @param size Width and height of the rectangle.
+   *
+   * @param angle The rotation angle in a clockwise direction. When the angle is 0, 90, 180, 270 etc.,
+   * the rectangle becomes an up-right rectangle.
+   */
+  public constructor(center: Point2f, size: Size2f, angle: float);
+
+  /**
+   *   Any 3 end points of the [RotatedRect]. They must be given in order (either clockwise or
+   * anticlockwise).
+   */
+  public constructor(point1: Point2f, point2: Point2f, point3: Point2f);
+
+  public boundingRect(): Rect;
+
+  public boundingRect2f(): Rect_;
+
+  /**
+   *   returns 4 vertices of the rectangle
+   *
+   * @param pts The points array for storing rectangle vertices. The order is bottomLeft, topLeft,
+   * topRight, bottomRight.
+   */
+  public points(pts: Point2f): Point2f;
+}

package/src/types/opencv/_hacks.ts

@@ -0,0 +1,323 @@
+// Scalar, Point, Rect, etc are defined by opencv.js (helpers.js) and we need to declare them manually:
+
+export declare class Range {
+  public start: number;
+  public end: number;
+  public constructor(start: number, end: number);
+}
+
+export declare class Scalar extends Array<number> {
+  public static all(...v: number[]): Scalar;
+}
+// Hack: expose Mat super classes like Mat_, InputArray, Vector, OutputArray we make them alias of Mat to simplify and make it work
+export {
+  Mat as InputArray,
+  Mat as InputArrayOfArrays,
+  Mat as InputOutputArray,
+  Mat as InputOutputArrayOfArrays,
+  Mat as OutputArray,
+  Mat as OutputArrayOfArrays,
+} from "./Mat";
+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 {
+  public constructor(x: number, y: number);
+  public x: number;
+  public y: number;
+}
+
+export declare class Size {
+  public constructor(width: number, height: number);
+  public width: number;
+  public height: number;
+}
+
+export declare class Rect {
+  public constructor();
+  public constructor(point: Point, size: Size);
+  public constructor(x: number, y: number, width: number, height: number);
+  public x: number;
+  public y: number;
+  public width: number;
+  public height: number;
+}
+
+export declare class TermCriteria {
+  public type: number;
+  public maxCount: number;
+  public epsilon: number;
+  public constructor();
+  public 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 {
+  public minVal: number;
+  public maxVal: number;
+  public minLoc: Point;
+  public maxLoc: Point;
+  public constructor();
+  public constructor(
+    minVal: number,
+    maxVal: number,
+    minLoc: Point,
+    maxLoc: Point,
+  );
+}
+
+// expose emscripten / opencv.js specifics
+
+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;
+}
+
+// emscripten embind internals
+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 {
+  public constructor(videoSource: HTMLVideoElement | string);
+  public read(m: Mat): any;
+  public 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;
+}
+
+// TODO this types should be exposed by the tool - want to make it work:
+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;
+
+// Missing imports:
+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/src/types/opencv/_types.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";