@stdmx/opencv4nodejs-prebuilt-install 4.1.206

package/lib/opencv4nodejs.js

@@ -0,0 +1,28 @@
+const promisify = require("./promisify");
+const extendWithJsSources = require("./src");
+
+const isElectronWebpack =
+  // assume module required by webpack if no system path inv envs
+  !process.env.path &&
+  // detect if electron https://github.com/electron/electron/issues/2288
+  global.window &&
+  global.window.process &&
+  global.window.process.type &&
+  global.navigator &&
+  (global.navigator.userAgent || "").toLowerCase().indexOf(" electron/") > -1;
+
+let cv;
+
+try {
+  cv = isElectronWebpack
+    ? require("../build/Release/opencv4nodejs.node")
+    : require("./cv");
+
+  // promisify async methods
+  cv = promisify(cv);
+  cv = extendWithJsSources(cv);
+} catch (err) {
+  console.log(`opencv4nodejs library isn't connected. platform should be x64 - current ${process.arch}, node12-21 - current ${process.version}, only mac,win,linux - current ${process.platform}`);
+}
+
+module.exports = cv;

package/lib/promisify.js

@@ -0,0 +1,37 @@
+const isFn = obj => typeof obj === 'function';
+const isAsyncFn = fn => fn.prototype.constructor.name.endsWith('Async');
+
+const promisify = (fn) => function () {
+  if (isFn(arguments[arguments.length - 1])) {
+    return fn.apply(this, arguments);
+  }
+
+  return new Promise((resolve, reject) => {
+    const args = Array.prototype.slice.call(arguments);
+    args.push(function(err, res) {
+      if (err) {
+        return reject(err);
+      }
+      return resolve(res);
+    });
+
+    fn.apply(this, args);
+  });
+};
+
+module.exports = (cv) => {
+  const fns = Object.keys(cv).filter(k => isFn(cv[k])).map(k => cv[k]);
+  const asyncFuncs = fns.filter(isAsyncFn);
+  const clazzes = fns.filter(fn => !!Object.keys(fn.prototype).length);
+
+  clazzes.forEach((clazz) => {
+    const protoFnKeys = Object.keys(clazz.prototype).filter(k => isAsyncFn(clazz.prototype[k]));
+    protoFnKeys.forEach(k => clazz.prototype[k] = promisify(clazz.prototype[k]));
+  });
+
+  asyncFuncs.forEach((fn) => {
+    cv[fn.prototype.constructor.name] = promisify(fn);
+  });
+
+  return cv;
+};

package/lib/src/drawUtils.js

@@ -0,0 +1,192 @@
+module.exports = function(cv) {
+  function reshapeRectAtBorders(rect, imgDim) {
+    const newX = Math.min(Math.max(0, rect.x), imgDim.cols)
+    const newY = Math.min(Math.max(0, rect.y), imgDim.rows)
+    return new cv.Rect(
+      newX,
+      newY,
+      Math.min(rect.width, imgDim.cols - newX),
+      Math.min(rect.height, imgDim.rows - newY)
+    )
+  }
+
+  function getDefaultTextParams() {
+    return ({
+      fontType: cv.FONT_HERSHEY_SIMPLEX,
+      fontSize: 0.8,
+      thickness: 2,
+      lineType: cv.LINE_4
+    })
+  }
+
+  function insertText(boxImg, text, { x, y }, opts) {
+    const {
+      fontType,
+      fontSize,
+      color,
+      thickness,
+      lineType
+    } = Object.assign(
+      {},
+      getDefaultTextParams(),
+      { color: new cv.Vec(255, 255, 255) },
+      opts
+    )
+
+    boxImg.putText(
+      text,
+      new cv.Point(x, y),
+      fontType,
+      fontSize,
+      color,
+      thickness,
+      lineType,
+      0
+    )
+    return boxImg
+  }
+
+  function getTextSize(text, opts) {
+    const {
+      fontType,
+      fontSize,
+      thickness
+    } = Object.assign({}, getDefaultTextParams(), opts)
+
+    const { size, baseLine } = cv.getTextSize(text, fontType, fontSize, thickness)
+    return { width: size.width, height: size.height, baseLine }
+  }
+
+  function getMaxWidth(textLines) {
+    const getTextWidth = (text, opts) => getTextSize(text, opts).width
+    return textLines.reduce((maxWidth, t) => {
+      const w = getTextWidth(t.text, t)
+      return (maxWidth < w ? w : maxWidth)
+    }, 0)
+  }
+
+  function getBaseLine(textLine) {
+    return getTextSize(textLine.text, textLine).baseLine
+  }
+
+  function getLineHeight(textLine) {
+    return getTextSize(textLine.text, textLine).height
+  }
+
+  function getTextHeight(textLines) {
+    return textLines.reduce(
+      (height, t) => height + getLineHeight(t),
+      0
+    )
+  }
+
+  function drawTextBox(img, upperLeft, textLines, alpha) {
+    const padding = 10
+    const linePadding = 10
+
+    const { x, y } = upperLeft
+    const rect = reshapeRectAtBorders(
+      new cv.Rect(
+        x,
+        y,
+        getMaxWidth(textLines) + (2 * padding),
+        getTextHeight(textLines) + (2 * padding) + ((textLines.length - 1) * linePadding)
+      ),
+      img
+    )
+
+    const boxImg = img.getRegion(rect).mul(alpha)
+    let pt = new cv.Point(padding, padding)
+    textLines.forEach(
+      (textLine, lineNumber) => {
+        const opts = Object.assign(
+          {},
+          getDefaultTextParams(),
+          textLine
+        )
+
+        pt = pt.add(new cv.Point(0, getLineHeight(textLine)))
+
+        insertText(
+          boxImg,
+          textLine.text,
+          pt,
+          opts
+        )
+
+        pt = pt.add(new cv.Point(0, linePadding))
+      }
+    )
+    boxImg.copyTo(img.getRegion(rect))
+    return img
+  }
+
+  function drawDetection(img, inputRect, opts = {}) {
+    const rect = inputRect.toSquare()
+
+    const { x, y, width, height } = rect
+
+    const segmentLength = width / (opts.segmentFraction || 6);
+    const upperLeft = new cv.Point(x, y)
+    const bottomLeft = new cv.Point(x, y + height)
+    const upperRight = new cv.Point(x + width, y)
+    const bottomRight = new cv.Point(x + width, y + height)
+
+    const drawParams = Object.assign(
+      {},
+      { thickness: 2 },
+      opts
+    )
+
+    img.drawLine(
+      upperLeft,
+      upperLeft.add(new cv.Point(0, segmentLength)),
+      drawParams
+    )
+    img.drawLine(
+      upperLeft,
+      upperLeft.add(new cv.Point(segmentLength, 0)),
+      drawParams
+    )
+
+    img.drawLine(
+      bottomLeft,
+      bottomLeft.add(new cv.Point(0, -segmentLength)),
+      drawParams
+    )
+    img.drawLine(
+      bottomLeft,
+      bottomLeft.add(new cv.Point(segmentLength, 0)),
+      drawParams
+    )
+
+    img.drawLine(
+      upperRight,
+      upperRight.add(new cv.Point(0, segmentLength)),
+      drawParams
+    )
+    img.drawLine(
+      upperRight,
+      upperRight.add(new cv.Point(-segmentLength, 0)),
+      drawParams
+    )
+
+    img.drawLine(
+      bottomRight,
+      bottomRight.add(new cv.Point(0, -segmentLength)),
+      drawParams
+    )
+    img.drawLine(
+      bottomRight,
+      bottomRight.add(new cv.Point(-segmentLength, 0)),
+      drawParams
+    )
+    return rect
+  }
+
+  return ({
+    drawTextBox,
+    drawDetection
+  })
+
+}

package/lib/src/index.js

@@ -0,0 +1,12 @@
+const makeDrawUtils = require('./drawUtils')
+
+module.exports = function(cv) {
+  const {
+    drawTextBox,
+    drawDetection
+  } = makeDrawUtils(cv)
+
+  cv.drawTextBox = drawTextBox
+  cv.drawDetection = drawDetection
+  return cv
+}

package/lib/typings/AGASTDetector.d.ts

@@ -0,0 +1,9 @@
+import { KeyPointDetector } from './KeyPointDetector.d';
+
+export class AGASTDetector extends KeyPointDetector {
+  readonly threshold: number;
+  readonly type: number;
+  readonly nonmaxSuppression: boolean;
+  constructor(threshold?: number, nonmaxSuppression?: boolean, type?: number);
+  constructor(params: { threshold?: number, nonmaxSuppression?: boolean, type?: number });
+}

package/lib/typings/AKAZEDetector.d.ts

@@ -0,0 +1,13 @@
+import { FeatureDetector } from './FeatureDetector.d';
+
+export class AKAZEDetector extends FeatureDetector {
+  readonly descriptorType: number;
+  readonly descriptorSize: number;
+  readonly descriptorChannels: number;
+  readonly nOctaves: number;
+  readonly nOctaveLayers: number;
+  readonly diffusivity: number;
+  readonly threshold: number;
+  constructor(descriptorType?: number, descriptorSize?: number, descriptorChannels?: number, threshold?: number, nOctaves?: number, nOctaveLayers?: number, diffusivity?: number);
+  constructor(params: { descriptorType?: number, descriptorSize?: number, descriptorChannels?: number, threshold?: number, nOctaves?: number, nOctaveLayers?: number, diffusivity?: number });
+}

package/lib/typings/BFMatcher.d.ts

@@ -0,0 +1,11 @@
+import {Mat} from "./Mat";
+import {DescriptorMatch} from "./DescriptorMatch";
+
+export class BFMatcher {
+    constructor(normType: number, crossCheck?: boolean);
+    constructor(params: { normType: number, crossCheck?: boolean });
+    match(descriptors1: Mat, descriptors2: Mat): DescriptorMatch[];
+    matchAsync(descriptors1: Mat, descriptors2: Mat): Promise<DescriptorMatch[]>;
+    knnMatch(descriptors1: Mat, descriptors2: Mat, k: number): Array<[DescriptorMatch]|[any]>;
+    knnMatchAsync(descriptors1: Mat, descriptors2: Mat, k: number): Promise<Array<[DescriptorMatch]|[any]>>;
+}

package/lib/typings/BRISKDetector.d.ts

@@ -0,0 +1,9 @@
+import { FeatureDetector } from './FeatureDetector';
+
+export class BRISKDetector extends FeatureDetector {
+  readonly thresh: number;
+  readonly octaves: number;
+  readonly patternScale: number;
+  constructor(thresh?: number, octaves?: number, patternScale?: number);
+  constructor(params: { thresh?: number, octaves?: number, patternScale?: number });
+}

package/lib/typings/BackgroundSubtractorKNN.d.ts

@@ -0,0 +1,9 @@
+import { Mat } from './Mat.d';
+
+export class BackgroundSubtractorKNN {
+  readonly history: number;
+  readonly dist2Threshold: number;
+  readonly detectShadows: boolean;
+  constructor(history?: number, varThreshold?: number, detectShadows?: boolean);
+  apply(frame: Mat, learningRate?: number): Mat;
+}

package/lib/typings/BackgroundSubtractorMOG2.d.ts

@@ -0,0 +1,9 @@
+import { Mat } from './Mat.d';
+
+export class BackgroundSubtractorMOG2 {
+  readonly history: number;
+  readonly varThreshold: number;
+  readonly detectShadows: boolean;
+  constructor(history?: number, varThreshold?: number, detectShadows?: boolean);
+  apply(frame: Mat, learningRate?: number): Mat;
+}

package/lib/typings/CascadeClassifier.d.ts

@@ -0,0 +1,12 @@
+import { Size } from './Size.d';
+import { Mat } from './Mat.d';
+import { Rect } from './Rect.d';
+
+export class CascadeClassifier {
+  constructor(xmlFilePath: string);
+  detectMultiScale(img: Mat, scaleFactor?: number, minNeighbors?: number, flags?: number, minSize?: Size, maxSize?: Size): { objects: Rect[], numDetections: number[] };
+  detectMultiScaleAsync(img: Mat, scaleFactor?: number, minNeighbors?: number, flags?: number, minSize?: Size, maxSize?: Size): Promise<{ objects: Rect[], numDetections: number[] }>;
+  detectMultiScaleGpu(img: Mat, scaleFactor?: number, minNeighbors?: number, flags?: number, minSize?: Size, maxSize?: Size): Rect[];
+  detectMultiScaleWithRejectLevels(img: Mat, scaleFactor?: number, minNeighbors?: number, flags?: number, minSize?: Size, maxSize?: Size): { objects: Rect[], rejectLevels: number[], levelWeights: number[] };
+  detectMultiScaleWithRejectLevelsAsync(img: Mat, scaleFactor?: number, minNeighbors?: number, flags?: number, minSize?: Size, maxSize?: Size): Promise<{ objects: Rect[], rejectLevels: number[], levelWeights: number[] }>;
+}

package/lib/typings/Contour.d.ts

@@ -0,0 +1,30 @@
+import { Rect } from './Rect.d';
+import { RotatedRect } from './RotatedRect.d';
+import { Moments } from './Moments.d';
+import { Point2 } from './Point2.d';
+import { Vec4 } from './Vec4.d';
+
+export class Contour {
+  readonly numPoints: number;
+  readonly area: number;
+  readonly isConvex: boolean;
+  readonly hierarchy: Vec4;
+  constructor();
+  constructor(pts: Point2[]);
+  constructor(pts: number[][]);
+  approxPolyDP(epsilon: number, closed: boolean): Point2[];
+  approxPolyDPContour(epsilon: number, closed: boolean): Contour;
+  arcLength(closed?: boolean): number;
+  boundingRect(): Rect;
+  convexHull(clockwise?: boolean): Contour;
+  convexHullIndices(clockwise?: boolean): number[];
+  convexityDefects(hullIndices: number[]): Vec4[];
+  fitEllipse(): RotatedRect;
+  getPoints(): Point2[];
+  matchShapes(contour2: Contour, method: number): number;
+  minAreaRect(): RotatedRect;
+  minEnclosingCircle(): { center: Point2, radius: number };
+  minEnclosingTriangle(): Point2[];
+  moments(): Moments;
+  pointPolygonTest(pt: Point2): number;
+}

package/lib/typings/DescriptorMatch.d.ts

@@ -0,0 +1,5 @@
+export class DescriptorMatch {
+  readonly queryIdx: number;
+  readonly trainIdx: number;
+  readonly distance: number;
+}

package/lib/typings/DetectionROI.d.ts

@@ -0,0 +1,8 @@
+import { Point2 } from './Point2.d';
+
+export class DetectionROI {
+  readonly scale: number;
+  readonly locations: Point2[];
+  readonly confidences: number[];
+  constructor();
+}

package/lib/typings/EigenFaceRecognizer.d.ts

@@ -0,0 +1,5 @@
+import { FaceRecognizer } from './FaceRecognizer';
+
+export class EigenFaceRecognizer extends FaceRecognizer {
+  constructor(num_components?: number, threshold?: number);
+}

package/lib/typings/FASTDetector.d.ts

@@ -0,0 +1,9 @@
+import { KeyPointDetector } from './KeyPointDetector';
+
+export class FASTDetector extends KeyPointDetector {
+  readonly threshold: number;
+  readonly type: number;
+  readonly nonmaxSuppression: boolean;
+  constructor(threshold?: number, nonmaxSuppression?: boolean, type?: number);
+  constructor(params: { threshold?: number, nonmaxSuppression?: boolean, type?: number });
+}

package/lib/typings/FaceRecognizer.d.ts

@@ -0,0 +1,10 @@
+import { Mat } from './Mat';
+
+export class FaceRecognizer {
+  load(file: string): void;
+  predict(img: Mat): { label: number, confidence: number };
+  predictAsync(img: Mat): Promise<{ label: number, confidence: number }>;
+  save(file: string): void;
+  train(trainImages: Mat[], labels: number[]): void;
+  trainAsync(trainImages: Mat[], labels: number[]): Promise<void>;
+}

package/lib/typings/Facemark.d.ts

@@ -0,0 +1,19 @@
+import { Mat } from "./Mat.d";
+import { Rect } from "./Rect.d";
+import { Point2 } from "./Point2.d";
+
+export class Facemark {
+  addTrainingSample(image: Mat, landmarks: number[][]): boolean;
+  addTrainingSampleAsync(image: Mat, landmarks: number[][]): Promise<boolean>;
+  loadModel(model: string): void;
+  loadModelAsync(model: string): Promise<void>;
+  getFaces(image: Mat): Rect[];
+  getFacesAsync(image: Mat): Promise<Rect[]>;
+  setFaceDetector(callback: Function): boolean;
+  training(): void;
+  trainingAsync(): Promise<void>;
+  fit(image: Mat, faces: Rect[]): Point2[][];
+  fitAsync(image: Mat, faces: Rect[]): Promise<Point2[][]>;
+  save(file: string): void;
+  load(file: string): void;
+}

package/lib/typings/FacemarkAAMParams.d.ts

@@ -0,0 +1,13 @@
+export class FacemarkAAMParams {
+  readonly m: number;
+  readonly maxM: number;
+  readonly maxN: number;
+  readonly modelFilename: string;
+  readonly n: number;
+  readonly nIter: number;
+  readonly saveModel: boolean;
+  readonly scales: number[];
+  readonly textureMaxM: number;
+  readonly verbose: boolean;
+  constructor();
+}

package/lib/typings/FacemarkLBF.d.ts

@@ -0,0 +1,3 @@
+import { Facemark } from "./Facemark";
+
+export class FacemarkLBF extends Facemark {}

package/lib/typings/FacemarkLBFParams.d.ts

@@ -0,0 +1,21 @@
+import { Rect } from "./Rect.d";
+
+export class FacemarkLBFParams {
+  readonly baggingOverlap: number;
+  readonly cascadeFace: string;
+  readonly detectROI: Rect;
+  readonly featsM: number[];
+  readonly initShapeN: number;
+  readonly modelFilename: string;
+  readonly nLandmarks: number;
+  readonly pupils: number[];
+  readonly radiusM: number[];
+  readonly saveModel: boolean;
+  readonly seed: number;
+  readonly shapeOffset: number;
+  readonly stagesN: number;
+  readonly treeDepth: number;
+  readonly treeN: number;
+  readonly verbose: boolean;
+  constructor();
+}

package/lib/typings/FacemarkrAAM.d.ts

@@ -0,0 +1,3 @@
+import { Facemark } from "./Facemark";
+
+export class FacemarkAAM extends Facemark {}

package/lib/typings/FeatureDetector.d.ts

@@ -0,0 +1,8 @@
+import { KeyPointDetector } from './KeyPointDetector';
+import { KeyPoint } from './KeyPoint.d';
+import { Mat } from './Mat.d';
+
+export class FeatureDetector extends KeyPointDetector {
+  compute(image: Mat, keypoints: KeyPoint[]): Mat;
+  computeAsync(image: Mat, keypoints: KeyPoint[]): Promise<Mat>;
+}

package/lib/typings/FisherFaceRecognizer.d.ts

@@ -0,0 +1,5 @@
+import { FaceRecognizer } from './FaceRecognizer';
+
+export class FisherFaceRecognizer extends FaceRecognizer {
+  constructor(num_components?: number, threshold?: number);
+}

package/lib/typings/GFTTDetector.d.ts

@@ -0,0 +1,12 @@
+import { KeyPointDetector } from './KeyPointDetector';
+
+export class GFTTDetector  extends KeyPointDetector {
+  readonly maxFeatures: number;
+  readonly blockSize: number;
+  readonly qualityLevel: number;
+  readonly minDistance: number;
+  readonly k: number;
+  readonly harrisDetector: boolean;
+  constructor(maxFeatures?: number, qualityLevel?: number, minDistance?: number, blockSize?: number, harrisDetector?: boolean, k?: number);
+  constructor(params: { maxFeatures?: number, qualityLevel?: number, minDistance?: number, blockSize?: number, harrisDetector?: boolean, k?: number });
+}

package/lib/typings/HOGDescriptor.d.ts

@@ -0,0 +1,41 @@
+import { Mat } from './Mat.d';
+import { Size } from './Size.d';
+import { Rect } from './Rect.d';
+import { Point2 } from './Point2.d';
+
+export class HOGDescriptor {
+  readonly winSize: Size;
+  readonly blockSize: Size;
+  readonly blockStride: Size;
+  readonly cellSize: Size;
+  readonly nbins: number;
+  readonly derivAperture: number;
+  readonly histogramNormType: number;
+  readonly nlevels: number;
+  readonly winSigma: number;
+  readonly L2HysThreshold: number;
+  readonly gammaCorrection: boolean;
+  readonly signedGradient: boolean;
+  constructor(winSize?: Size, blockSize?: Size, blockStride?: Size, cellSize?: Size, nbins?: number, derivAperture?: number, winSigma?: number, histogramNormType?: number, L2HysThreshold?: number, gammaCorrection?: boolean, nlevels?: number, signedGradient?: boolean);
+  constructor(params: { winSize?: Size, blockSize?: Size, blockStride?: Size, cellSize?: Size, nbins?: number, derivAperture?: number, winSigma?: number, histogramNormType?: number, L2HysThreshold?: number, gammaCorrection?: boolean, nlevels?: number, signedGradient?: boolean });
+  checkDetectorSize(): boolean;
+  compute(img: Mat, winStride?: Size, padding?: Size, locations?: Point2[]): number[];
+  computeAsync(img: Mat, winStride?: Size, padding?: Size, locations?: Point2[]): Promise<number[]>;
+  computeGradient(img: Mat, paddingTL?: Size, paddingBR?: Size): { grad: Mat, angleOfs: Mat };
+  computeGradientAsync(img: Mat, paddingTL?: Size, paddingBR?: Size): Promise<{ grad: Mat, angleOfs: Mat }>;
+  detect(img: Mat, hitThreshold?: number, winStride?: Size, padding?: Size, searchLocations?: Point2[]): { foundLocations: Point2[], weights: number[] };
+  detectAsync(img: Mat, hitThreshold?: number, winStride?: Size, padding?: Size, searchLocations?: Point2[]): Promise<{ foundLocations: Point2[], weights: number[] }>;
+  detectMultiScale(img: Mat, hitThreshold?: number, winStride?: Size, padding?: Size, scale?: number, finalThreshold?: number, useMeanshiftGrouping?: boolean): { foundLocations: Rect[], foundWeights: number[] };
+  detectMultiScaleAsync(img: Mat, hitThreshold?: number, winStride?: Size, padding?: Size, scale?: number, finalThreshold?: number, useMeanshiftGrouping?: boolean): Promise<{ foundLocations: Rect[], foundWeights: number[] }>;
+  detectMultiScaleROI(img: Mat, hitThreshold?: number, groupThreshold?: number): Rect[];
+  detectMultiScaleROIAsync(img: Mat, hitThreshold?: number, groupThreshold?: number): Promise<Rect[]>;
+  detectROI(img: Mat, locations: Point2[], hitThreshold?: number, winStride?: Size, padding?: Size): { foundLocations: Point2[], confidences: number[] };
+  detectROIAsync(img: Mat, locations: Point2[], hitThreshold?: number, winStride?: Size, padding?: Size): Promise<{ foundLocations: Point2[], confidences: number[] }>;
+  getDaimlerPeopleDetector(): number[];
+  getDefaultPeopleDetector(): number[];
+  groupRectangles(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): Rect[];
+  groupRectanglesAsync(rectList: Rect[], weights: number[], groupThreshold: number, eps: number): Promise<Rect[]>;
+  load(path: string): void;
+  save(path: string): void;
+  setSVMDetector(detector: number[]): void;
+}

package/lib/typings/KAZEDetector.d.ts

@@ -0,0 +1,12 @@
+import { FeatureDetector } from './FeatureDetector.d';
+
+export class KAZEDetector extends FeatureDetector {
+  readonly extended: boolean;
+  readonly upright: boolean;
+  readonly nOctaves: number;
+  readonly nOctaveLayers: number;
+  readonly diffusivity: number;
+  readonly threshold: number;
+  constructor(extended?: boolean, upright?: boolean, threshold?: number, nOctaves?: number, nOctaveLayers?: number, diffusivity?: number);
+  constructor(params: { extended?: boolean, upright?: boolean, threshold?: number, nOctaves?: number, nOctaveLayers?: number, diffusivity?: number });
+}

package/lib/typings/KeyPoint.d.ts

@@ -0,0 +1,12 @@
+import { Point2 } from './Point2.d';
+
+export class KeyPoint {
+  readonly point: Point2;
+  readonly size: number;
+  readonly angle: number;
+  readonly response: number;
+  readonly octave: number;
+  readonly class_id: number;
+  readonly localId: number;
+  constructor(point: Point2, size: number, angle: number, response: number, octave: number, class_id: number);
+}

package/lib/typings/KeyPointDetector.d.ts

@@ -0,0 +1,7 @@
+import { KeyPoint } from './KeyPoint.d';
+import { Mat } from './Mat.d';
+
+export class KeyPointDetector {
+  detect(image: Mat): KeyPoint[];
+  detectAsync(image: Mat): Promise<KeyPoint[]>;
+}

package/lib/typings/LBPHFaceRecognizer.d.ts

@@ -0,0 +1,5 @@
+import { FaceRecognizer } from './FaceRecognizer';
+
+export class LBPHFaceRecognizer extends FaceRecognizer {
+  constructor(radius?: number, neighbors?: number, grid_x?: number, grid_y?: number, threshold?: number);
+}

package/lib/typings/MSERDetector.d.ts

@@ -0,0 +1,20 @@
+import { KeyPointDetector } from './KeyPointDetector.d';
+import { Point2 } from './Point2.d';
+import { Rect } from './Rect.d';
+import { Mat } from './Mat.d';
+
+export class MSERDetector extends KeyPointDetector {
+  readonly delta: number;
+  readonly minArea: number;
+  readonly maxArea: number;
+  readonly maxEvolution: number;
+  readonly edgeBlurSize: number;
+  readonly maxVariation: number;
+  readonly minDiversity: number;
+  readonly areaThreshold: number;
+  readonly minMargin: number;
+  constructor(delta?: number, minArea?: number, maxArea?: number, maxVariation?: number, minDiversity?: number, maxEvolution?: number, areaThreshold?: number, minMargin?: number, edgeBlurSize?: number);
+  constructor(params: { delta?: number, minArea?: number, maxArea?: number, maxVariation?: number, minDiversity?: number, maxEvolution?: number, areaThreshold?: number, minMargin?: number, edgeBlurSize?: number });
+  detectRegions(image: Mat): { msers: Point2[][], bboxes: Rect[] };
+  detectRegionsAsync(image: Mat): Promise< { msers: Point2[][], bboxes: Rect[] }>;
+}