@stdmx/opencv4nodejs-prebuilt-install 4.1.206

package/lib/typings/Mat.d.ts

@@ -0,0 +1,327 @@
+import { Size } from './Size.d';
+import { TermCriteria } from './TermCriteria.d';
+import { RotatedRect } from './RotatedRect.d';
+import { Rect } from './Rect.d';
+import { Moments } from './Moments.d';
+import { Contour } from './Contour.d';
+import { Point2 } from './Point2.d';
+import { Point3 } from './Point3.d';
+import { Vec2 } from './Vec2.d';
+import { Vec3 } from './Vec3.d';
+import { Vec4 } from './Vec4.d';
+
+export class Mat {
+  readonly rows: number;
+  readonly cols: number;
+  readonly type: number;
+  readonly channels: number;
+  readonly depth: number;
+  readonly dims: number;
+  readonly empty: boolean;
+  readonly step: number;
+  readonly elemSize: number;
+  readonly sizes: number[];
+  constructor();
+  constructor(channels: Mat[]);
+  constructor(rows: number, cols: number, type: number);
+  constructor(rows: number, cols: number, type: number, fillValue: number);
+  constructor(rows: number, cols: number, type: number, fillValue: number[]);
+  constructor(rows: number, cols: number, type: number, fillValue: number[]);
+  constructor(rows: number, cols: number, type: number, fillValue: number[]);
+  constructor(dataArray: number[][], type: number);
+  constructor(dataArray: number[][][], type: number);
+  constructor(dataArray: number[][][], type: number);
+  constructor(dataArray: number[][][], type: number);
+  constructor(data: Buffer, rows: number, cols: number, type?: number);
+  abs(): Mat;
+  absdiff(otherMat: Mat): Mat;
+  adaptiveThreshold(maxVal: number, adaptiveMethod: number, thresholdType: number, blockSize: number, C: number): Mat;
+  adaptiveThresholdAsync(maxVal: number, adaptiveMethod: number, thresholdType: number, blockSize: number, C: number): Promise<Mat>;
+  add(otherMat: Mat): Mat;
+  addWeighted(alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Mat;
+  addWeightedAsync(alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Promise<Mat>;
+  and(otherMat: Mat): Mat;
+  at(row: number, col: number): number;
+  at(row: number, col: number): Vec2;
+  at(row: number, col: number): Vec3;
+  at(row: number, col: number): Vec4;
+  at(idx: number[]): number;
+  at(idx: number[]): Vec2;
+  at(idx: number[]): Vec3;
+  at(idx: number[]): Vec4;
+  atRaw(row: number, col: number): number;
+  atRaw(row: number, col: number): number[];
+  atRaw(row: number, col: number): number[];
+  atRaw(row: number, col: number): number[];
+  bgrToGray(): Mat;
+  bgrToGrayAsync(): Promise<Mat>;
+  bilateralFilter(d: number, sigmaColor: number, sigmaSpace: number, borderType?: number): Mat;
+  bilateralFilterAsync(d: number, sigmaColor: number, sigmaSpace: number, borderType?: number): Promise<Mat>;
+  bitwiseAnd(otherMat: Mat): Mat;
+  bitwiseNot(): Mat;
+  bitwiseOr(otherMat: Mat): Mat;
+  bitwiseXor(otherMat: Mat): Mat;
+  blur(kSize: Size, anchor?: Point2, borderType?: number): Mat;
+  blurAsync(kSize: Size, anchor?: Point2, borderType?: number): Promise<Mat>;
+  boxFilter(ddepth: number, ksize: Size, anchor?: Point2, normalize?: boolean, borderType?: number): Mat;
+  boxFilterAsync(ddepth: number, ksize: Size, anchor?: Point2, normalize?: boolean, borderType?: number): Promise<Mat>;
+  buildPyramid(maxLevel: number, borderType?: number): Mat[];
+  buildPyramidAsync(maxLevel: number, borderType?: number): Promise<Mat[]>;
+  calibrationMatrixValues(imageSize: Size, apertureWidth: number, apertureHeight: number): { fovx: number, fovy: number, focalLength: number, principalPoint: Point2, aspectRatio: number };
+  calibrationMatrixValuesAsync(imageSize: Size, apertureWidth: number, apertureHeight: number): Promise<{ fovx: number, fovy: number, focalLength: number, principalPoint: Point2, aspectRatio: number }>;
+  canny(threshold1: number, threshold2: number, apertureSize?: number, L2gradient?: boolean): Mat;
+  cannyAsync(threshold1: number, threshold2: number, apertureSize?: number, L2gradient?: boolean): Promise<Mat>;
+  compareHist(H2: Mat, method: number): number;
+  compareHistAsync(H2: Mat, method: number): Promise<number>;
+  connectedComponents(connectivity?: number, ltype?: number): Mat;
+  connectedComponentsAsync(connectivity?: number, ltype?: number): Promise<Mat>;
+  connectedComponentsWithStats(connectivity?: number, ltype?: number): { labels: Mat, stats: Mat, centroids: Mat };
+  connectedComponentsWithStatsAsync(connectivity?: number, ltype?: number): Promise<{ labels: Mat, stats: Mat, centroids: Mat }>;
+  convertScaleAbs(alpha: number, beta: number): Mat;
+  convertScaleAbsAsync(alpha: number, beta: number): Promise<Mat>;
+  convertTo(type: number, alpha?: number, beta?: number): Mat;
+  convertToAsync(type: number, alpha?: number, beta?: number): Promise<Mat>;
+  copy(mask?: Mat): Mat;
+  copyAsync(mask?: Mat): Promise<Mat>;
+  copyMakeBorder(top: number, bottom: number, left: number, right: number, borderType?: number, value?: number | Vec2 | Vec3 | Vec4): Mat;
+  copyMakeBorderAsync(top: number, bottom: number, left: number, right: number, borderType?: number, value?: number | Vec2 | Vec3 | Vec4): Promise<Mat>;
+  copyTo(dst: Mat, mask?: Mat): Mat;
+  copyToAsync(dst: Mat, mask?: Mat): Promise<Mat>;
+  cornerEigenValsAndVecs(blockSize: number, ksize?: number, borderType?: number): Mat;
+  cornerEigenValsAndVecsAsync(blockSize: number, ksize?: number, borderType?: number): Promise<Mat>;
+  cornerHarris(blockSize: number, ksize: number, k: number, borderType?: number): Mat;
+  cornerHarrisAsync(blockSize: number, ksize: number, k: number, borderType?: number): Promise<Mat>;
+  cornerMinEigenVal(blockSize: number, ksize?: number, borderType?: number): Mat;
+  cornerMinEigenValAsync(blockSize: number, ksize?: number, borderType?: number): Promise<Mat>;
+  cornerSubPix(corners: Point2[], winSize: Size, zeroZone: Size, criteria: TermCriteria): Point2[];
+  cornerSubPixAsync(corners: Point2[], winSize: Size, zeroZone: Size, criteria: TermCriteria): Promise<Point2[]>;
+  correctMatches(points1: Point2[], points2: Point2[]): { newPoints1: Point2[], newPoints2: Point2[] };
+  correctMatchesAsync(points1: Point2[], points2: Point2[]): Promise<{ newPoints1: Point2[], newPoints2: Point2[] }>;
+  countNonZero(): number;
+  countNonZeroAsync(): Promise<number>;
+  cvtColor(code: number, dstCn?: number): Mat;
+  cvtColorAsync(code: number, dstCn?: number): Promise<Mat>;
+  dct(flags?: number): Mat;
+  dctAsync(flags?: number): Promise<Mat>;
+  decomposeEssentialMat(): { R1: Mat, R2: Mat, T: Vec3 };
+  decomposeEssentialMatAsync(): Promise<{ R1: Mat, R2: Mat, T: Vec3 }>;
+  decomposeHomographyMat(K: Mat): { returnValue: number, rotations: Mat[], translations: Mat[], normals: Mat[] };
+  decomposeHomographyMatAsync(K: Mat): Promise<{ returnValue: number, rotations: Mat[], translations: Mat[], normals: Mat[] }>;
+  decomposeProjectionMatrix(): { cameraMatrix: Mat, rotMatrix: Mat, transVect: Vec4, rotMatrixX: Mat, rotMatrixY: Mat, rotMatrixZ: Mat, eulerAngles: Mat };
+  decomposeProjectionMatrixAsync(): Promise<{ cameraMatrix: Mat, rotMatrix: Mat, transVect: Vec4, rotMatrixX: Mat, rotMatrixY: Mat, rotMatrixZ: Mat, eulerAngles: Mat }>;
+  determinant(): number;
+  dft(flags?: number, nonzeroRows?: number): Mat;
+  dftAsync(flags?: number, nonzeroRows?: number): Promise<Mat>;
+  dilate(kernel: Mat, anchor?: Point2, iterations?: number, borderType?: number): Mat;
+  dilateAsync(kernel: Mat, anchor?: Point2, iterations?: number, borderType?: number): Promise<Mat>;
+  distanceTransform(distanceType: number, maskSize: number, dstType?: number): Mat;
+  distanceTransformAsync(distanceType: number, maskSize: number, dstType?: number): Promise<Mat>;
+  distanceTransformWithLabels(distanceType: number, maskSize: number, labelType?: number): { labels: Mat, dist: Mat };
+  distanceTransformWithLabelsAsync(distanceType: number, maskSize: number, labelType?: number): Promise<{ labels: Mat, dist: Mat }>;
+  div(s: number): Mat;
+  dot(): Mat;
+  drawArrowedLine(pt0: Point2, pt1: Point2, color?: Vec3, thickness?: number, lineType?: number, shift?: number, tipLength?: number): void;
+  drawChessboardCorners(patternSize: Size, corners: Point2[], patternWasFound: boolean): void;
+  drawChessboardCornersAsync(patternSize: Size, corners: Point2[], patternWasFound: boolean): Promise<void>;
+  drawCircle(center: Point2, radius: number, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  drawContours(contours: Contour[], color: Vec3, contourIdx?: number, maxLevel?: number, offset?: Point2, lineType?: number, thickness?: number, shift?: number): void;
+  drawEllipse(box: RotatedRect, color?: Vec3, thickness?: number, lineType?: number): void;
+  drawEllipse(center: Point2, axes: Size, angle: number, startAngle: number, endAngle: number, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  drawFillConvexPoly(pts: Point2[], color?: Vec3, lineType?: number, shift?: number): void;
+  drawFillPoly(pts: Point2[][], color?: Vec3, lineType?: number, shift?: number, offset?: Point2): void;
+  drawLine(pt0: Point2, pt1: Point2, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  drawPolylines(pts: Point2[][], isClosed: boolean, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  drawRectangle(pt0: Point2, pt1: Point2, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  drawRectangle(rect: Rect, color?: Vec3, thickness?: number, lineType?: number, shift?: number): void;
+  eigen(): Mat;
+  eigenAsync(): Promise<Mat>;
+  equalizeHist(): Mat;
+  equalizeHistAsync(): Promise<Mat>;
+  erode(kernel: Mat, anchor?: Point2, iterations?: number, borderType?: number): Mat;
+  erodeAsync(kernel: Mat, anchor?: Point2, iterations?: number, borderType?: number): Promise<Mat>;
+  exp(): Mat;
+  log(): Mat;
+  filter2D(ddepth: number, kernel: Mat, anchor?: Point2, delta?: number, borderType?: number): Mat;
+  filter2DAsync(ddepth: number, kernel: Mat, anchor?: Point2, delta?: number, borderType?: number): Promise<Mat>;
+  filterSpeckles(newVal: number, maxSpeckleSize: number, maxDiff: number): { newPoints1: Point2[], newPoints2: Point2[] };
+  filterSpecklesAsync(newVal: number, maxSpeckleSize: number, maxDiff: number): Promise<{ newPoints1: Point2[], newPoints2: Point2[] }>;
+  find4QuadCornerSubpix(corners: Point2[], regionSize: Size): boolean;
+  find4QuadCornerSubpixAsync(corners: Point2[], regionSize: Size): Promise<boolean>;
+  findChessboardCorners(patternSize: Size, flags?: number): { returnValue: boolean, corners: Point2[] };
+  findChessboardCornersAsync(patternSize: Size, flags?: number): Promise<{ returnValue: boolean, corners: Point2[] }>;
+  findContours(mode: number, method: number, offset?: Point2): Contour[];
+  findContoursAsync(mode: number, method: number, offset?: Point2): Promise<Contour[]>;
+  findEssentialMat(points1: Point2[], points2: Point2[], method?: number, prob?: number, threshold?: number): { E: Mat, mask: Mat };
+  findEssentialMatAsync(points1: Point2[], points2: Point2[], method?: number, prob?: number, threshold?: number): Promise<{ E: Mat, mask: Mat }>;
+  findNonZero(): Point2[];
+  findNonZeroAsync(): Promise<Point2[]>;
+  flattenFloat(rows: number, cols: number): Mat;
+  flip(flipCode: number): Mat;
+  flipAsync(flipCode: number): Promise<Mat>;
+  floodFill(seedPoint: Point2, newVal: number, mask?: Mat, loDiff?: number, upDiff?: number, flags?: number): { returnValue: number, rect: Rect };
+  floodFill(seedPoint: Point2, newVal: Vec3, mask?: Mat, loDiff?: Vec3, upDiff?: Vec3, flags?: number): { returnValue: number, rect: Rect };
+  floodFillAsync(seedPoint: Point2, newVal: number, mask?: Mat, loDiff?: number, upDiff?: number, flags?: number): Promise<{ returnValue: number, rect: Rect }>;
+  floodFillAsync(seedPoint: Point2, newVal: Vec3, mask?: Mat, loDiff?: Vec3, upDiff?: Vec3, flags?: number): Promise<{ returnValue: number, rect: Rect }>;
+  gaussianBlur(kSize: Size, sigmaX: number, sigmaY?: number, borderType?: number): Mat;
+  gaussianBlurAsync(kSize: Size, sigmaX: number, sigmaY?: number, borderType?: number): Promise<Mat>;
+  getData(): Buffer;
+  getDataAsync(): Promise<Buffer>;
+  getDataAsArray(): number[][];
+  getDataAsArray(): number[][][];
+  getDataAsArray(): number[][][];
+  getDataAsArray(): number[][][];
+  getOptimalNewCameraMatrix(distCoeffs: number[], imageSize: Size, alpha: number, newImageSize?: Size, centerPrincipalPoint?: boolean): { out: Mat, validPixROI: Rect };
+  getOptimalNewCameraMatrixAsync(distCoeffs: number[], imageSize: Size, alpha: number, newImageSize?: Size, centerPrincipalPoint?: boolean): Promise<{ out: Mat, validPixROI: Rect }>;
+  getRegion(region: Rect): Mat;
+  goodFeaturesToTrack(maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Point2[];
+  goodFeaturesToTrackAsync(maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Promise<Point2[]>;
+  grabCut(mask: Mat, rect: Rect, bgdModel: Mat, fgdModel: Mat, iterCount: number, mode: number): void;
+  grabCutAsync(mask: Mat, rect: Rect, bgdModel: Mat, fgdModel: Mat, iterCount: number, mode: number): Promise<void>;
+  guidedFilter(guide: Mat, radius: number, eps: number, ddepth?: number): Mat;
+  guidedFilterAsync(guide: Mat, radius: number, eps: number, ddepth?: number): Promise<Mat>;
+  hDiv(otherMat: Mat): Mat;
+  hMul(otherMat: Mat): Mat;
+  houghCircles(method: number, dp: number, minDist: number, param1?: number, param2?: number, minRadius?: number, maxRadius?: number): Vec3[];
+  houghCirclesAsync(method: number, dp: number, minDist: number, param1?: number, param2?: number, minRadius?: number, maxRadius?: number): Promise<Vec3[]>;
+  houghLines(rho: number, theta: number, threshold: number, srn?: number, stn?: number, min_theta?: number, max_theta?: number): Vec2[];
+  houghLinesAsync(rho: number, theta: number, threshold: number, srn?: number, stn?: number, min_theta?: number, max_theta?: number): Promise<Vec2[]>;
+  houghLinesP(rho: number, theta: number, threshold: number, minLineLength?: number, maxLineGap?: number): Vec4[];
+  houghLinesPAsync(rho: number, theta: number, threshold: number, minLineLength?: number, maxLineGap?: number): Promise<Vec4[]>;
+  idct(flags?: number): Mat;
+  idctAsync(flags?: number): Promise<Mat>;
+  idft(flags?: number, nonzeroRows?: number): Mat;
+  idftAsync(flags?: number, nonzeroRows?: number): Promise<Mat>;
+  inRange(lower: number, upper: number): Mat;
+  inRange(lower: Vec3, upper: Vec3): Mat;
+  inRangeAsync(lower: number, upper: number): Promise<Mat>;
+  inRangeAsync(lower: Vec3, upper: Vec3): Promise<Mat>;
+  integral(sdepth?: number, sqdepth?: number): { sum: Mat, sqsum: Mat, tilted: Mat };
+  integralAsync(sdepth?: number, sqdepth?: number): Promise<{ sum: Mat, sqsum: Mat, tilted: Mat }>;
+  laplacian(ddepth: number, ksize?: number, scale?: number, delta?: number, borderType?: number): Mat;
+  laplacianAsync(ddepth: number, ksize?: number, scale?: number, delta?: number, borderType?: number): Promise<Mat>;
+  matMul(B: Mat): Mat;
+  matMulDeriv(B: Mat): { dABdA: Mat, dABdB: Mat };
+  matMulDerivAsync(B: Mat): Promise<{ dABdA: Mat, dABdB: Mat }>;
+  matchTemplate(template: Mat, method: number, mask?: Mat): Mat;
+  matchTemplateAsync(template: Mat, method: number, mask?: Mat): Promise<Mat>;
+  mean(): Vec4;
+  meanAsync():  Promise<Vec4>;
+  meanStdDev(mask?: Mat): { mean: Mat, stddev: Mat };
+  meanStdDevAsync(mask?: Mat): Promise<{ mean: Mat, stddev: Mat }>;
+  medianBlur(kSize: number): Mat;
+  medianBlurAsync(kSize: number): Promise<Mat>;
+  minMaxLoc(mask?: Mat): { minVal: number, maxVal: number, minLoc: Point2, maxLoc: Point2 };
+  minMaxLocAsync(mask?: Mat): Promise<{ minVal: number, maxVal: number, minLoc: Point2, maxLoc: Point2 }>;
+  moments(): Moments;
+  momentsAsync(): Promise<Moments>;
+  morphologyEx(kernel: Mat, morphType: number, anchor?: Point2, iterations?: number, borderType?: number): Mat;
+  morphologyExAsync(kernel: Mat, morphType: number, anchor?: Point2, iterations?: number, borderType?: number): Promise<Mat>;
+  mul(s: number): Mat;
+  mulSpectrums(mat2: Mat, dftRows?: boolean, conjB?: boolean): Mat;
+  mulSpectrumsAsync(mat2: Mat, dftRows?: boolean, conjB?: boolean): Promise<Mat>;
+  norm(src2: Mat, normType?: number, mask?: Mat): number;
+  norm(normType?: number, mask?: Mat): number;
+  normalize(alpha?: number, beta?: number, normType?: number, dtype?: number, mask?: Mat): Mat;
+  or(otherMat: Mat): Mat;
+  padToSquare(color: Vec3): Mat;
+  perspectiveTransform(m: Mat): Mat;
+  perspectiveTransformAsync(m: Mat): Promise<Mat>;
+  pop_back(numRows?: number): Mat;
+  pop_backAsync(numRows?: number): Promise<Mat>;
+  popBack(numRows?: number): Mat;
+  popBackAsync(numRows?: number): Promise<Mat>;
+  push_back(mat: Mat): Mat;
+  push_backAsync(mat: Mat): Promise<Mat>;
+  pushBack(mat: Mat): Mat;
+  pushBackAsync(mat: Mat): Promise<Mat>;
+  putText(text: string, origin: Point2, fontFace: number, fontScale: number, color?: Vec3, lineType?: number, thickness?: number, bottomLeftOrigin?: boolean): void;
+  pyrDown(size?: Size, borderType?: number): Mat;
+  pyrDownAsync(size?: Size, borderType?: number): Promise<Mat>;
+  pyrUp(size?: Size, borderType?: number): Mat;
+  pyrUpAsync(size?: Size, borderType?: number): Promise<Mat>;
+  recoverPose(E: Mat, points1: Point2[], points2: Point2[], mask?: Mat): { returnValue: number, R: Mat, T: Vec3 };
+  recoverPoseAsync(E: Mat, points1: Point2[], points2: Point2[], mask?: Mat): Promise<{ returnValue: number, R: Mat, T: Vec3 }>;
+  rectify3Collinear(distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], cameraMatrix3: Mat, distCoeffs3: number[], imageSize: Size, R12: Mat, T12: Vec3, R13: Mat, T13: Vec3, alpha: number, newImageSize: Size, flags: number): { returnValue: number, R1: Mat, R2: Mat, R3: Mat, P1: Mat, P2: Mat, P3: Mat, Q: Mat, roi1: Rect, roi2: Rect };
+  rectify3CollinearAsync(distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], cameraMatrix3: Mat, distCoeffs3: number[], imageSize: Size, R12: Mat, T12: Vec3, R13: Mat, T13: Vec3, alpha: number, newImageSize: Size, flags: number): Promise<{ returnValue: number, R1: Mat, R2: Mat, R3: Mat, P1: Mat, P2: Mat, P3: Mat, Q: Mat, roi1: Rect, roi2: Rect }>;
+  reduce(dim: number, rtype: number, dtype?: number): Mat;
+  reduceAsync(dim: number, rtype: number, dtype?: number): Promise<Mat>;
+  reprojectImageTo3D(Q: Mat, handleMissingValues?: boolean, ddepth?: number): Mat;
+  reprojectImageTo3DAsync(Q: Mat, handleMissingValues?: boolean, ddepth?: number): Promise<Mat>;
+  rescale(factor: number): Mat;
+  rescaleAsync(factor: number): Promise<Mat>;
+  resize(rows: number, cols: number, fx?: number, fy?: number, interpolation?: number): Mat;
+  resize(dsize: Size, fx?: number, fy?: number, interpolation?: number): Mat;
+  resizeAsync(rows: number, cols: number, fx?: number, fy?: number, interpolation?: number): Promise<Mat>;
+  resizeAsync(dsize: Size, fx?: number, fy?: number, interpolation?: number): Promise<Mat>;
+  resizeToMax(maxRowsOrCols: number): Mat;
+  resizeToMaxAsync(maxRowsOrCols: number): Promise<Mat>;
+  rodrigues(): { dst: Mat, jacobian: Mat };
+  rodriguesAsync(): Promise<{ dst: Mat, jacobian: Mat }>;
+  rotate(rotateCode: number): Mat;
+  rotateAsync(rotateCode: number): Promise<Mat>;
+  rqDecomp3x3(): { returnValue: Vec3, mtxR: Mat, mtxQ: Mat, Qx: Mat, Qy: Mat, Qz: Mat };
+  rqDecomp3x3Async(): Promise<{ returnValue: Vec3, mtxR: Mat, mtxQ: Mat, Qx: Mat, Qy: Mat, Qz: Mat }>;
+  scharr(ddepth: number, dx: number, dy: number, scale?: number, delta?: number, borderType?: number): Mat;
+  scharrAsync(ddepth: number, dx: number, dy: number, scale?: number, delta?: number, borderType?: number): Promise<Mat>;
+  seamlessClone(dst: Mat, mask: Mat, p: Point2, flags: number): Mat;
+  seamlessCloneAsync(dst: Mat, mask: Mat, p: Point2, flags: number): Promise<Mat>;
+  sepFilter2D(ddepth: number, kernelX: Mat, kernelY: Mat, anchor?: Point2, delta?: number, borderType?: number): Mat;
+  sepFilter2DAsync(ddepth: number, kernelX: Mat, kernelY: Mat, anchor?: Point2, delta?: number, borderType?: number): Promise<Mat>;
+  set(row: number, col: number, value: number): void;
+  set(row: number, col: number, value: number[]): void;
+  set(row: number, col: number, value: number[]): void;
+  set(row: number, col: number, value: number[]): void;
+  set(row: number, col: number, value: Vec2): void;
+  set(row: number, col: number, value: Vec3): void;
+  set(row: number, col: number, value: Vec4): void;
+  setTo(value: number, mask?: Mat): Mat;
+  setTo(value: Vec2, mask?: Mat): Mat;
+  setTo(value: Vec3, mask?: Mat): Mat;
+  setTo(value: Vec4, mask?: Mat): Mat;
+  setToAsync(value: number, mask?: Mat): Promise<Mat>;
+  setToAsync(value: Vec2, mask?: Mat): Promise<Mat>;
+  setToAsync(value: Vec3, mask?: Mat): Promise<Mat>;
+  setToAsync(value: Vec4, mask?: Mat): Promise<Mat>;
+  sobel(ddepth: number, dx: number, dy: number, ksize?: number, scale?: number, delta?: number, borderType?: number): Mat;
+  sobelAsync(ddepth: number, dx: number, dy: number, ksize?: number, scale?: number, delta?: number, borderType?: number): Promise<Mat>;
+  solve(mat2: Mat, flags?: number): Mat;
+  solveAsync(mat2: Mat, flags?: number): Promise<Mat>;
+  split(): Mat[];
+  splitAsync(): Promise<Mat[]>;
+  splitChannels(): Mat[];
+  splitChannelsAsync(): Promise<Mat[]>;
+  sqrBoxFilter(ddepth: number, ksize: Size, anchor?: Point2, normalize?: boolean, borderType?: number): Mat;
+  sqrBoxFilterAsync(ddepth: number, ksize: Size, anchor?: Point2, normalize?: boolean, borderType?: number): Promise<Mat>;
+  sqrt(): Mat;
+  stereoRectify(distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], imageSize: Size, R: Mat, T: Vec3, flags?: number, alpha?: number, newImageSize?: Size): { R1: Mat, R2: Mat, P1: Mat, P2: Mat, Q: Mat, roi1: Rect, roi2: Rect };
+  stereoRectifyAsync(distCoeffs1: number[], cameraMatrix2: Mat, distCoeffs2: number[], imageSize: Size, R: Mat, T: Vec3, flags?: number, alpha?: number, newImageSize?: Size): Promise<{ R1: Mat, R2: Mat, P1: Mat, P2: Mat, Q: Mat, roi1: Rect, roi2: Rect }>;
+  sub(otherMat: Mat): Mat;
+  sum(): number;
+  sum(): Vec2;
+  sum(): Vec3;
+  sum(): Vec4;
+  sumAsync(): Promise<number>;
+  sumAsync(): Promise<Vec2>;
+  sumAsync(): Promise<Vec3>;
+  sumAsync(): Promise<Vec4>;
+  threshold(thresh: number, maxVal: number, type: number): Mat;
+  thresholdAsync(thresh: number, maxVal: number, type: number): Promise<Mat>;
+  transform(m: Mat): Mat;
+  transformAsync(m: Mat): Promise<Mat>;
+  transpose(): Mat;
+  triangulatePoints(projPoints1: Point2[], projPoints2: Point2[]): Mat;
+  triangulatePointsAsync(projPoints1: Point2[], projPoints2: Point2[]): Promise<Mat>;
+  undistort(cameraMatrix: Mat, distCoeffs: Mat): Mat;
+  undistortAsync(cameraMatrix: Mat, distCoeffs: Mat): Promise<Mat>;
+  validateDisparity(cost: Mat, minDisparity: number, numberOfDisparities: number, disp12MaxDisp?: number): void;
+  validateDisparityAsync(cost: Mat, minDisparity: number, numberOfDisparities: number, disp12MaxDisp?: number): Promise<void>;
+  warpAffine(transforMationMatrix: Mat, size?: Size, flags?: number, borderMode?: number, borderValue?: Vec3): Mat;
+  warpAffineAsync(transforMationMatrix: Mat, size?: Size, flags?: number, borderMode?: number, borderValue?: Vec3): Promise<Mat>;
+  warpPerspective(transforMationMatrix: Mat, size?: Size, flags?: number, borderMode?: number, borderValue?: Vec3): Mat;
+  warpPerspectiveAsync(transforMationMatrix: Mat, size?: Size, flags?: number, borderMode?: number, borderValue?: Vec3): Promise<Mat>;
+  watershed(markers: Mat): Mat;
+  watershedAsync(markers: Mat): Promise<Mat>;
+  release(): void;
+
+  static eye(rows: number, cols: number, type: number): Mat;
+}

package/lib/typings/Moments.d.ts

@@ -0,0 +1,27 @@
+export class Moments {
+  readonly m00: number;
+  readonly m10: number;
+  readonly m01: number;
+  readonly m20: number;
+  readonly m11: number;
+  readonly m02: number;
+  readonly m30: number;
+  readonly m21: number;
+  readonly m12: number;
+  readonly m03: number;
+  readonly mu20: number;
+  readonly mu11: number;
+  readonly mu02: number;
+  readonly mu30: number;
+  readonly mu21: number;
+  readonly mu12: number;
+  readonly mu03: number;
+  readonly nu20: number;
+  readonly nu11: number;
+  readonly nu02: number;
+  readonly nu30: number;
+  readonly nu21: number;
+  readonly nu12: number;
+  readonly nu03: number;
+  huMoments(): number[];
+}

package/lib/typings/MultiTracker.d.ts

@@ -0,0 +1,12 @@
+import { Mat } from './Mat.d';
+import { Rect } from './Rect.d';
+
+export class MultiTracker {
+  constructor();
+  addBOOSTING(frame: Mat, boundingBox: Rect): boolean;
+  addKCF(frame: Mat, boundingBox: Rect): boolean;
+  addMEDIANFLOW(frame: Mat, boundingBox: Rect): boolean;
+  addMil(frame: Mat, boundingBox: Rect): boolean;
+  addTLD(frame: Mat, boundingBox: Rect): boolean;
+  update(frame: Mat): Rect[];
+}

package/lib/typings/Net.d.ts

@@ -0,0 +1,10 @@
+import { Mat } from './Mat.d';
+
+export class Net {
+  forward(inputName?: string): Mat;
+  forward(outBlobNames?: string[]): Mat[];
+  forwardAsync(inputName?: string): Promise<Mat>;
+  forwardAsync(outBlobNames?: string[]): Promise<Mat[]>;
+  setInput(blob: Mat, inputName?: string): void;
+  setInputAsync(blob: Mat, inputName?: string): Promise<void>;
+}

package/lib/typings/OCRHMMClassifier.d.ts

@@ -0,0 +1,7 @@
+import { Mat } from './Mat.d';
+
+export class OCRHMMClassifier {
+  constructor(classifier: OCRHMMClassifier, vocabulary: string, transitionPropabilitiesTable: Mat, emissionPropabilitiesTable: Mat, mode?: number);
+  eval(img: Mat): { classes: number[], confidences: number[] };
+  evalAsync(img: Mat): Promise<{ classes: number[], confidences: number[] }>;
+}

package/lib/typings/OCRHMMDecoder.d.ts

@@ -0,0 +1,11 @@
+import { Mat } from './Mat.d';
+import { Rect } from './Rect.d';
+import { OCRHMMClassifier } from './OCRHMMClassifier.d';
+
+export class OCRHMMDecoder {
+  constructor(classifier: OCRHMMClassifier, vocabulary: string, transitionPropabilitiesTable: Mat, emissionPropabilitiesTable: Mat, mode?: number);
+  run(img: Mat, mask?: Mat, componentLevel?: number): string;
+  runAsync(img: Mat, mask?: Mat, componentLevel?: number): Promise<string>;
+  runWithInfo(img: Mat, mask?: Mat, componentLevel?: number): { outputText: string, rects: Rect[], words: string[], confidences: number[] };
+  runWithInfoAsync(img: Mat, mask?: Mat, componentLevel?: number): Promise<{ outputText: string, rects: Rect[], words: string[], confidences: number[] }>;
+}

package/lib/typings/ORBDetector.d.ts

@@ -0,0 +1,15 @@
+import { FeatureDetector } from './FeatureDetector.d';
+
+export class ORBDetector extends FeatureDetector {
+  readonly maxFeatures: number;
+  readonly nLevels: number;
+  readonly edgeThreshold: number;
+  readonly firstLevel: number;
+  readonly WTA_K: number;
+  readonly scoreType: number;
+  readonly patchSize: number;
+  readonly fastThreshold: number;
+  readonly scaleFactor: number;
+  constructor(maxFeatures?: number, scaleFactor?: number, nLevels?: number, edgeThreshold?: number, firstLevel?: number, WTA_K?: number, scoreType?: number, patchSize?: number, fastThreshold?: number);
+  constructor(params: { maxFeatures?: number, scaleFactor?: number, nLevels?: number, edgeThreshold?: number, firstLevel?: number, WTA_K?: number, scoreType?: number, patchSize?: number, fastThreshold?: number });
+}

package/lib/typings/ParamGrid.d.ts

@@ -0,0 +1,7 @@
+export class ParamGrid {
+  readonly minVal: number;
+  readonly maxVal: number;
+  readonly logStep: number;
+  constructor(paramId: number);
+  constructor(minVal: number, maxVal: number, logStep: number);
+}

package/lib/typings/Point.d.ts

@@ -0,0 +1,8 @@
+export class Point {
+  add(otherPoint: Point): Point;
+  at(index: number): number;
+  div(s: number): Point;
+  mul(s: number): Point;
+  norm(): number;
+  sub(otherPoint: Point): Point;
+}

package/lib/typings/Point2.d.ts

@@ -0,0 +1,7 @@
+import { Point } from './Point.d';
+
+export class Point2 extends Point {
+  readonly x: number;
+  readonly y: number;
+  constructor(x: number, y: number);
+}

package/lib/typings/Point3.d.ts

@@ -0,0 +1,8 @@
+import { Point } from './Point';
+
+export class Point3 extends Point {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  constructor(x: number, y: number, z: number);
+}

package/lib/typings/Rect.d.ts

@@ -0,0 +1,20 @@
+import { Size } from './Size.d';
+
+export class Rect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  constructor();
+  constructor(x: number, y: number, width: number, height: number);
+  and(rect2: Rect): Rect;
+  or(rect2: Rect): Rect;
+  pad(factor: number): Rect;
+  pad(size: Size): Rect;
+  padAsync(factor: number): Promise<Rect>;
+  padAsync(size: Size): Promise<Rect>;
+  rescale(factor: number): Rect;
+  rescaleAsync(factor: number): Promise<Rect>;
+  toSquare(): Rect;
+  toSquareAsync(): Promise<Rect>;
+}

package/lib/typings/RotatedRect.d.ts

@@ -0,0 +1,12 @@
+import { Size } from './Size.d';
+import { Rect } from './Rect.d';
+import { Point2 } from './Point2.d';
+
+export class RotatedRect {
+  readonly center: Point2;
+  readonly size: Size;
+  readonly angle: number;
+  constructor();
+  constructor(center: Point2, size: Size, angle: number);
+  boundingRect(): Rect;
+}

package/lib/typings/SIFTDetector.d.ts

@@ -0,0 +1,11 @@
+import { FeatureDetector } from './FeatureDetector.d';
+
+export class SIFTDetector extends FeatureDetector {
+  readonly nfeatures: number;
+  readonly nOctaveLayers: number;
+  readonly contrastThreshold: number;
+  readonly edgeThreshold: number;
+  readonly sigma: number;
+  constructor(nFeatures?: number, nOctaveLayers?: number, contrastThreshold?: number, edgeThreshold?: number, sigma?: number);
+  constructor(params: { nFeatures?: number, nOctaveLayers?: number, contrastThreshold?: number, edgeThreshold?: number, sigma?: number });
+}

package/lib/typings/SURFDetector.d.ts

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

package/lib/typings/SVM.d.ts

@@ -0,0 +1,32 @@
+import { Mat } from './Mat.d';
+import { TrainData } from './TrainData.d';
+import { ParamGrid } from './ParamGrid.d';
+
+export class SVM {
+  readonly c: number;
+  readonly coef0: number;
+  readonly degree: number;
+  readonly gamma: number;
+  readonly nu: number;
+  readonly p: number;
+  readonly kernelType: number;
+  readonly classWeights: Mat;
+  readonly varCount: number;
+  readonly isTrained: boolean;
+  constructor(c?: number, coef0?: number, degree?: number, gamma?: number, nu?: number, p?: number, kernelType?: number, classWeights?: Mat);
+  constructor(params: { c?: number, coef0?: number, degree?: number, gamma?: number, nu?: number, p?: number, kernelType?: number, classWeights?: Mat });
+  calcError(trainData: TrainData, test: boolean): { error: number, responses: Mat };
+  getSupportVectors(): Mat;
+  getDecisionFunction(): { rho: number, alpha: Mat, svidx: Mat };
+  load(file: string): void;
+  predict(sample: number[], flags?: number): number;
+  predict(samples: Mat, flags?: number): number[];
+  save(file: string): void;
+  setParams(c?: number, coef0?: number, degree?: number, gamma?: number, nu?: number, p?: number, kernelType?: number, classWeights?: Mat): void;
+  train(trainData: TrainData, flags?: number): boolean;
+  train(samples: Mat, layout: number, responses: Mat): boolean;
+  trainAsync(trainData: TrainData, flags?: number): Promise<boolean>;
+  trainAsync(samples: Mat, layout: number, responses: Mat): Promise<boolean>;
+  trainAuto(trainData: TrainData, kFold?: number, cGrid?: ParamGrid, gammaGrid?: ParamGrid, pGrid?: ParamGrid, nuGrid?: ParamGrid, coeffGrid?: ParamGrid, degreeGrid?: ParamGrid, balanced?: boolean): Mat;
+  trainAutoAsync(trainData: TrainData, kFold?: number, cGrid?: ParamGrid, gammaGrid?: ParamGrid, pGrid?: ParamGrid, nuGrid?: ParamGrid, coeffGrid?: ParamGrid, degreeGrid?: ParamGrid, balanced?: boolean): Promise<Mat>;
+}

package/lib/typings/SimpleBlobDetector.d.ts

@@ -0,0 +1,6 @@
+import { FeatureDetector } from './FeatureDetector.d';
+import { SimpleBlobDetectorParams } from './SimpleBlobDetectorParams.d';
+
+export class SimpleBlobDetector extends FeatureDetector {
+  constructor(params: SimpleBlobDetectorParams);
+}

package/lib/typings/SimpleBlobDetectorParams.d.ts

@@ -0,0 +1,22 @@
+export class SimpleBlobDetectorParams {
+  blobColor: number;
+  filterByArea: boolean;
+  filterByCircularity: boolean;
+  filterByColor: boolean;
+  filterByConvexity: boolean;
+  filterByInertia: boolean;
+  maxArea: number;
+  maxCircularity: number;
+  maxConvexity: number;
+  maxInertiaRatio: number;
+  maxThreshold: number;
+  minArea: number;
+  minCircularity: number;
+  minConvexity: number;
+  minDistBetweenBlobs: number;
+  minInertiaRatio: number;
+  minRepeatability: number;
+  minThreshold: number;
+  thresholdStep: number;
+  constructor();
+}

package/lib/typings/Size.d.ts

@@ -0,0 +1,6 @@
+export class Size {
+  readonly width: number;
+  readonly height: number;
+  constructor();
+  constructor(width: number, height: number);
+}

package/lib/typings/SuperpixelLSC.d.ts

@@ -0,0 +1,12 @@
+import { Mat } from './Mat.d';
+
+export class SuperpixelLSC {
+  readonly image: Mat;
+  readonly labels: Mat;
+  readonly labelContourMask: Mat;
+  readonly regionSize: number;
+  readonly ratio: number;
+  readonly numCalculatedSuperpixels: number;
+  constructor(img: Mat, regionSize?: number, ratio?: number);
+  iterate(iterations?: number): void;
+}

package/lib/typings/SuperpixelSEEDS.d.ts

@@ -0,0 +1,15 @@
+import { Mat } from './Mat.d';
+
+export class SuperpixelSEEDS {
+  readonly image: Mat;
+  readonly labels: Mat;
+  readonly labelContourMask: Mat;
+  readonly num_superpixels: number;
+  readonly num_levels: number;
+  readonly prior: number;
+  readonly histogramBins: number;
+  readonly numCalculatedSuperpixels: number;
+  readonly doubleStep: boolean;
+  constructor(img: Mat, num_superpixels: number, num_levels: number, prior?: number, histogramBins?: number, doubleStep?: boolean);
+  iterate(iterations?: number): void;
+}

package/lib/typings/SuperpixelSLIC.d.ts

@@ -0,0 +1,13 @@
+import { Mat } from './Mat.d';
+
+export class SuperpixelSLIC {
+  readonly image: Mat;
+  readonly labels: Mat;
+  readonly labelContourMask: Mat;
+  readonly algorithm: number;
+  readonly regionSize: number;
+  readonly ruler: number;
+  readonly numCalculatedSuperpixels: number;
+  constructor(img: Mat, algorithm?: number, regionSize?: number, ruler?: number);
+  iterate(iterations?: number): void;
+}

package/lib/typings/TermCriteria.d.ts

@@ -0,0 +1,7 @@
+export class TermCriteria {
+  readonly type: number;
+  readonly maxCount: number;
+  readonly epsilon: number;
+  constructor();
+  constructor(type: number, maxCount: number, epsilon: number);
+}