@stdmx/opencv4nodejs-prebuilt-install 4.1.217 → 4.1.223

package/README.md

@@ -45,7 +45,7 @@ Set your own properties inside of package.json for opencv4nodejs up to 4.6.0 dep
 ```nodejs
   "opencv4nodejs": {
     "autoBuildWithoutContrib": 1,
-    "autoBuildOpencvVersion": "4.1.1",
+    "autoBuildOpencvVersion": "4.1.2",
     "autoBuildFlags": "-DBUILD_opencv_world=1 -DBUILD_LIST=core,highgui,videoio -DOPENCV_FORCE_3RDPARTY_BUILD=ON -DBUILD_PNG=ON -DBUILD_TIFF=ON -DBUILD_JASPER=ON -DBUILD_JPEG=ON -DBUILD_ZLIB=ON -DBUILD_OPENEXR=ON -DWITH_FFMPEG=OFF -DWITH_GSTREAMER=ON -DBUILD_USE_SYMLINKS=OFF -DWITH_VTK=OFF",
     "disableAutoBuild": 1
   },

package/lib/src/deprecations.js

@@ -0,0 +1,34 @@
+
+const assert = require('assert');
+
+module.exports = function (cv) {
+
+  // deprecate wrapper for the old calcHist API
+  const _calcHist = cv.calcHist;
+  cv.calcHist = function calcHist(img, histAxes, mask) {
+    assert(img instanceof cv.Mat, 'Imgproc::CalcHist - Error: expected argument 0 to be of type Mat');
+    assert(Array.isArray(histAxes), 'Imgproc::CalcHist - Error: expected argument 1 to be of type array of HistAxes');
+
+    histAxes = histAxes.slice();
+
+    let warningThrown = false;
+    const len = histAxes.length;
+
+    for (let i = 0; i < len; ++i) {
+      const entry = histAxes[i];
+      if (!(entry instanceof cv.HistAxes)) {
+        if (!warningThrown) {
+          warningThrown = true;
+          console.warn(`Imgproc::CalcHist - Deprecated support for object in argument 1 at index ${i}. Please switch to using HistAxes instances.`);
+        }
+        histAxes[i] = new cv.HistAxes(entry);
+      }
+    }
+
+    if (mask) {
+      return _calcHist(img, histAxes, mask);
+    }
+    return _calcHist(img, histAxes);
+  };
+
+};

package/lib/src/index.js

@@ -1,4 +1,5 @@
 const makeDrawUtils = require('./drawUtils')
+const deprecations  = require('./deprecations')
 
 module.exports = function(cv) {
   const {
@@ -8,5 +9,8 @@ module.exports = function(cv) {
 
   cv.drawTextBox = drawTextBox
   cv.drawDetection = drawDetection
+
+  deprecations(cv)
+
   return cv
 }

package/lib/typings/KeyPoint.d.ts

@@ -1,7 +1,7 @@
 import { Point2 } from './Point2.d';
 
 export class KeyPoint {
-  readonly point: Point2;
+  readonly pt: Point2;
   readonly size: number;
   readonly angle: number;
   readonly response: number;

package/lib/typings/Mat.d.ts

@@ -35,6 +35,14 @@ export class Mat {
   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;
@@ -197,6 +205,7 @@ export class 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;
@@ -222,6 +231,7 @@ export class 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;
@@ -234,7 +244,7 @@ export class 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;
+  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;

package/lib/typings/cv.d.ts

@@ -13,12 +13,22 @@ import { TermCriteria } from './TermCriteria.d';
 import { OCRHMMClassifier } from './OCRHMMClassifier.d';
 import { Net } from './Net.d';
 
-export interface HistAxes {
+export class HistAxes {
   channel: number;
   bins: number;
   ranges: number[];
+
+  constructor(opts: { channel: number, bins: number, ranges: [number, number] });
 }
 
+export function accumulate(src: Mat, dst: Mat, mask?: Mat): void;
+export function accumulateAsync(src: Mat, dst: Mat, mask?: Mat): Promise<void>;
+export function accumulateProduct(src1: Mat, src2: Mat, dst: Mat, mask?: Mat): void;
+export function accumulateProductAsync(src1: Mat, src2: Mat, dst:Mat, mask?: Mat): Promise<void>;
+export function accumulateSquare(src: Mat, dst: Mat, mask?: Mat): void;
+export function accumulateSquareAsync(src: Mat, dst: Mat, mask?: Mat): Promise<void>;
+export function accumulateWeighted(src: Mat, dst: Mat, alpha: number, mask?: Mat): void;
+export function accumulateWeightedAsync(src: Mat, dst: Mat, alpha: number, mask?: Mat): Promise<void>;
 export function addWeighted(mat: Mat, alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Mat;
 export function addWeightedAsync(mat: Mat, alpha: number, mat2: Mat, beta: number, gamma: number, dtype?: number): Promise<Mat>;
 export function applyColorMap(src: Mat, colormap: number | Mat): Mat;
@@ -29,7 +39,10 @@ export function blobFromImagesAsync(image: Mat[], scaleFactor?: number, size?: S
 export function blur(mat: Mat, kSize: Size, anchor?: Point2, borderType?: number): Mat;
 export function blurAsync(mat: Mat, kSize: Size, anchor?: Point2, borderType?: number): Promise<Mat>;
 export function NMSBoxes(bboxes: Rect[], scores: number[], scoreThreshold: number, nmsThreshold: number): number[];
+/** @deprecated */
+export function calcHist(img: Mat, histAxes: { channel: number, bins: number, ranges: [number, number] }[], mask?: Mat): Mat;
 export function calcHist(img: Mat, histAxes: HistAxes[], mask?: Mat): Mat;
+export function calcHistAsync(img: Mat, histAxes: HistAxes[], mask?: Mat): Promise<Mat>;
 export function calibrateCamera(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): { returnValue: number, rvecs: Vec3[], tvecs: Vec3[], distCoeffs: number[] };
 export function calibrateCameraAsync(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): Promise<{ returnValue: number, rvecs: Vec3[], tvecs: Vec3[], distCoeffs: number[] }>;
 export function calibrateCameraExtended(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, cameraMatrix: Mat, distCoeffs: number[], flags?: number, criteria?: TermCriteria): { returnValue: number, rvecs: Vec3[], tvecs: Vec3[], distCoeffs: number[], stdDeviationsIntrinsics: Mat, stdDeviationsExtrinsics: Mat, perViewErrors: number[] };
@@ -80,6 +93,8 @@ export function getBuildInformation(): string;
 export function getPerspectiveTransform(srcPoints: Point2[], dstPoints: Point2[]): Mat;
 export function getRotationMatrix2D(center: Point2, angle: number, scale?: number): Mat;
 export function getStructuringElement(shape: number, kernelSize: Size, anchor?: Point2): Mat;
+export function getTextSize(text: string, fontFace: number, fontScale: number, thickness: number): {size: Size, baseLine: number};
+export function getTextSizeAsync(text: string, fontFace: number, fontScale: number, thickness: number): Promise<{size: Size, baseLine: number}>;
 export function getValidDisparityROI(roi1: Rect[], roi2: Rect[], minDisparity: number, numberOfDisparities: number, SADWindowSize: number): Rect;
 export function getValidDisparityROIAsync(roi1: Rect[], roi2: Rect[], minDisparity: number, numberOfDisparities: number, SADWindowSize: number): Promise<Rect>;
 export function goodFeaturesToTrack(mat: Mat, maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Point2[];
@@ -97,6 +112,7 @@ export function imwriteAsync(filePath: string, img: Mat, flags?: number[]): Prom
 export function initCameraMatrix2D(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, aspectRatio?: number): Mat;
 export function initCameraMatrix2DAsync(objectPoints: Point3[], imagePoints: Point2[], imageSize: Size, aspectRatio?: number): Promise<Mat>;
 export function kmeans(data: Point2[], k: number, attempts: number, termCriteria: TermCriteria, flags: number): { labels: number[], centers: Point2[] };
+export function kmeans(data: Point3[], k: number, attempts: number, termCriteria: TermCriteria, flags: number): { labels: number[], centers: Point3[] };
 export function loadOCRHMMClassifierCNN(file: string): OCRHMMClassifier;
 export function loadOCRHMMClassifierCNNAsync(file: string): Promise<OCRHMMClassifier>;
 export function loadOCRHMMClassifierNM(file: string): OCRHMMClassifier;
@@ -194,6 +210,7 @@ export function transformAsync(mat: Mat, m: Mat): Promise<Mat>;
 export function undistortPoints(srcPoints: Point2[], cameraMatrix: Mat, distCoeffs: Mat): Point2[];
 export function undistortPointsAsync(srcPoints: Point2[], cameraMatrix: Mat, distCoeffs: Mat): Promise<Point2[]>;
 export function waitKey(delay?: number): number;
+export function waitKeyEx(delay?: number): number;
 
 export type DrawParams = {
   thickness?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdmx/opencv4nodejs-prebuilt-install",
-  "version": "4.1.217",
+  "version": "4.1.223",
   "description": "Asynchronous OpenCV 4.x nodejs bindings with JavaScript and TypeScript API.",
   "keywords": [
     "opencv",