@stdmx/opencv4nodejs-prebuilt-install 4.1.234 → 4.5.5-2

package/lib/typings/Mat.d.ts

@@ -1,337 +0,0 @@
-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;
-  accumulate(src: Mat, mask?: Mat): Mat;
-  accumulateAsync(src: Mat, mask?: Mat): Promise<Mat>;
-  accumulateProduct(src1: Mat, src2: Mat, mask?: Mat): Mat;
-  accumulateProductAsync(src1: Mat, src2:Mat, mask?: Mat): Promise<Mat>;
-  accumulateSquare(src: Mat, mask?: Mat): Mat;
-  accumulateSquareAsync(src: Mat, mask?: Mat): Promise<Mat>;
-  accumulateWeighted(src: Mat, alpha: number, mask?: Mat): Mat;
-  accumulateWeightedAsync(src: Mat, alpha: number, mask?: Mat): Promise<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 }>;
-  inv(): 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;
-  normalizeAsync(alpha?: number, beta?: number, normType?: number, dtype?: number, mask?: Mat): Promise<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, thickness?: number, lineType?: 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

@@ -1,27 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

package/lib/typings/SimpleBlobDetectorParams.d.ts

@@ -1,22 +0,0 @@
-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

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

package/lib/typings/SuperpixelLSC.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-}