Merge pull request #181 from justadudewhohacks/typescript-definitions

Typescript definitions

Author: justadudewhohacks

.gitattributes

@@ -1 +1,3 @@
-*.sh* text eol=lf
+*.sh* text eol=lf
+*.d.ts linguist-vendored=false
+/examples/* linguist-documentation=false

.gitignore

@@ -9,4 +9,5 @@ coverage
 coverage-report
 tmpdata
 data/dnn
-.idea/
+.idea/
+dist

.npmignore

@@ -14,4 +14,5 @@ coverage
 coverage-report
 tmpdata
 ci
-.dockerignore
+.dockerignore
+dist

cc/core/Point.cc

@@ -29,6 +29,8 @@ NAN_MODULE_INIT(Point::Init) {
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(Nan::New("Point").ToLocalChecked());
   target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Point2").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Point3").ToLocalChecked(), ctor->GetFunction());
 };
 
 NAN_METHOD(Point::New) {

cc/core/Vec.cc

@@ -43,6 +43,9 @@ NAN_MODULE_INIT(Vec::Init) {
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(Nan::New("Vec").ToLocalChecked());
   target->Set(Nan::New("Vec").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Vec2").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Vec3").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Vec4").ToLocalChecked(), ctor->GetFunction());
 };
 
 NAN_METHOD(Vec::New) {

examples/templateMatching/original.jpg renamed to data/findwaldo.jpg

@@ -5,7 +5,7 @@ const {
 } = require('../utils');
 
 module.exports = function () {
-  const modelPath = '../../data/dnn/facenet';
+  const modelPath = path.resolve(__dirname, '../../data/dnn/facenet');
 
   const prototxt = path.resolve(modelPath, 'facenet.prototxt');
   const modelFile = path.resolve(modelPath, 'res10_300x300_ssd_iter_140000.caffemodel');

examples/templateMatching/waldo.jpg renamed to data/waldo.jpg

@@ -46,7 +46,7 @@ function classifyImg(img) {
 
 const makeDrawClassDetections = predictions => (drawImg, className, getColor, thickness = 2) => {
   predictions
-    .filter(p => p.className === className)
+    .filter(p => classNames[p.classLabel] === className)
     .forEach(p => drawRect(drawImg, p.rect, getColor(), { thickness }));
   return drawImg;
 };

examples/dnn/loadFacenet.js

@@ -41,9 +41,13 @@ const lbph = new cv.LBPHFaceRecognizer();
 lbph.train(trainImgs, labels);
 
 const twoFacesImg = cv.imread(path.resolve(basePath, 'daryl-rick.jpg'));
-const faces = classifier.detectMultiScale(twoFacesImg.bgrToGray()).objects;
+const result = classifier.detectMultiScale(twoFacesImg.bgrToGray());
 
-faces.forEach((faceRect) => {
+const minDetections = 10;
+result.objects.forEach((faceRect, i) => {
+  if (result.numDetections[i] < minDetections) {
+    return;
+  }
   const faceImg = twoFacesImg.getRegion(faceRect).bgrToGray();
   const who = nameMappings[lbph.predict(faceImg).label];
 

examples/dnnSSDCoco.js

@@ -2,7 +2,7 @@
   "name": "opencv4nodejs_examples",
   "version": "1.1.0",
   "author": "justadudewhohacks",
-  "license": "ISC",
+  "license": "MIT",
   "dependencies": {},
   "devDependencies": {
     "eslint": "^3.18.0",

examples/faceRecognition1.js

@@ -3,8 +3,8 @@ const cv = require('../');
 
 const findWaldo = async () => {
   // Load images
-  const originalMat = await cv.imreadAsync(`${__dirname}/templateMatching/original.jpg`);
-  const waldoMat = await cv.imreadAsync(`${__dirname}/templateMatching/waldo.jpg`);
+  const originalMat = await cv.imreadAsync(`${__dirname}/../data/findwaldo.jpg`);
+  const waldoMat = await cv.imreadAsync(`${__dirname}/../data/waldo.jpg`);
 
   // Match template (the brightest locations indicate the highest match)
   const matched = originalMat.matchTemplate(waldoMat, 5);

examples/package.json

@@ -0,0 +1,96 @@
+import * as fs from 'fs';
+import * as cv from '../../';
+
+// a - z
+export const lccs = Array(26).fill(97).map((v, i) => v + i).map(ascii => String.fromCharCode(ascii));
+
+const invert = (img: cv.Mat) => img.threshold(254, 255, cv.THRESH_BINARY_INV);
+
+const getBoundingRect = (component: number[]) => new cv.Rect(
+  component[cv.CC_STAT_LEFT],
+  component[cv.CC_STAT_TOP],
+  component[cv.CC_STAT_WIDTH],
+  component[cv.CC_STAT_HEIGHT]
+);
+
+const getLetterBoundingRect = (img: cv.Mat, isIorJ: boolean) => {
+  const { stats } = invert(img).bgrToGray().connectedComponentsWithStats();
+  const componentsOrderedBySize =
+    stats.getDataAsArray().sort((s0, s1) => s1[cv.CC_STAT_AREA] - s0[cv.CC_STAT_AREA]);
+
+  if (componentsOrderedBySize.length < 2) {
+    return null;
+  }
+
+  // background actually is largest component so we take the next largest
+  let largestComponent = componentsOrderedBySize[1];
+  let letterRect = getBoundingRect(largestComponent);
+
+  if (isIorJ && componentsOrderedBySize.length > 2) {
+    let dotComponent = componentsOrderedBySize[2];
+
+    if (largestComponent[cv.CC_STAT_TOP] < dotComponent[cv.CC_STAT_TOP]) {
+      largestComponent = componentsOrderedBySize[2];
+      dotComponent = componentsOrderedBySize[1];
+      letterRect = getBoundingRect(largestComponent);
+    }
+
+    const dotRectXRight = dotComponent[cv.CC_STAT_LEFT] + dotComponent[cv.CC_STAT_WIDTH];
+    const xLeft = Math.min(letterRect.x, dotComponent[cv.CC_STAT_LEFT]);
+    const letterRectYBottom = letterRect.y + letterRect.height;
+
+    letterRect = new cv.Rect(
+      xLeft,
+      dotComponent[cv.CC_STAT_TOP],
+      Math.max(letterRect.width, dotRectXRight - xLeft),
+      (letterRectYBottom - dotComponent[cv.CC_STAT_TOP])
+    );
+  }
+
+  return letterRect;
+};
+
+export function centerLetterInImage (img: cv.Mat, isIorJ: boolean): cv.Mat {
+  const rect = getLetterBoundingRect(img, isIorJ);
+  if (!rect) {
+    return null;
+  }
+
+  const offX = (img.cols - rect.width) / 2;
+  const offY = (img.rows - rect.height) / 2;
+  const centeredRect = new cv.Rect(
+    offX,
+    offY,
+    rect.width,
+    rect.height
+  );
+
+  const centered = new cv.Mat(img.rows, img.cols, img.type, [255, 255, 255]);
+  img.getRegion(rect).copyTo(centered.getRegion(centeredRect));
+
+  return centered;
+};
+
+export function saveConfusionMatrix (
+  testDataFiles: any[],
+  predict: (mat: cv.Mat, isIorJ: boolean) => number,
+  numTestImagesPerClass: number,
+  outputFile: string
+): void {
+  const confusionMat = new cv.Mat(26, 26, cv.CV_64F, 0);
+  testDataFiles.forEach((files, label) => {
+    files.forEach((file: string) => {
+      const img = cv.imread(file);
+      const predictedLabel = predict(img, label === 8 || label === 9);
+      confusionMat.set(label, predictedLabel, confusionMat.at(label, predictedLabel) + 1);
+    });
+  });
+
+  const confusionMatMatrix = [[''].concat(lccs)].concat(
+    confusionMat.div(numTestImagesPerClass)
+      .getDataAsArray().map((col, l) => [lccs[l]].concat(`${col.map(v => Math.round(v * 100) / 100)}`))
+  );
+
+  const csvRows = confusionMatMatrix.map(cols => cols.join(';'));
+  fs.writeFileSync(outputFile, csvRows.join('\n'));
+};

examples/templateMatching.js

@@ -0,0 +1,11 @@
+# opencv4nodejs TypeScript examples
+
+### Install
+``` bash
+npm install
+```
+
+### Run
+``` bash
+npm run ts-node <example>.ts
+```

examples/typed/OCRTools.ts

@@ -0,0 +1,54 @@
+import * as cv from '../../';
+
+const detectAndComputeAsync = (det: cv.FeatureDetector, img: cv.Mat) =>
+  det.detectAsync(img)
+    .then(kps => det.computeAsync(img, kps)
+                      .then(desc => ({ kps, desc }))
+    );
+
+const img1 = cv.imread('../../data/s0.jpg');
+const img2 = cv.imread('../../data/s1.jpg');
+
+const detectorNames = [
+  'AKAZE',
+  'BRISK',
+  'KAZE',
+  'ORB'
+];
+
+const createDetectorFromName = (name: string) => new cv[`${name}Detector`]();
+
+// create 4 promises -> each detector detects and computes descriptors for img1 and img2
+const promises = detectorNames
+  .map(createDetectorFromName)
+  .map(det =>
+    // also detect and compute descriptors for img1 and img2 async
+    Promise.all([detectAndComputeAsync(det, img1), detectAndComputeAsync(det, img2)])
+      .then(allResults =>
+        cv.matchBruteForceAsync(
+          allResults[0].desc,
+          allResults[1].desc
+        )
+        .then(matches => ({
+          matches,
+          kps1: allResults[0].kps,
+          kps2: allResults[1].kps
+        }))
+      )
+);
+
+Promise.all(promises)
+  .then((allResults) => {
+    allResults.forEach((result, i) => {
+      const drawMatchesImg = cv.drawMatches(
+        img1,
+        img2,
+        result.kps1,
+        result.kps2,
+        result.matches
+      );
+      cv.imshowWait(detectorNames[i], drawMatchesImg);
+      cv.destroyAllWindows();
+    });
+  })
+  .catch(err => console.error(err));

examples/typed/README.md

@@ -0,0 +1,18 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as cv from '../../../';
+
+export function loadFacenet (): cv.Net {
+  const modelPath = path.resolve(__dirname, '../../../data/dnn/facenet');
+
+  const prototxt = path.resolve(modelPath, 'facenet.prototxt');
+  const modelFile = path.resolve(modelPath, 'res10_300x300_ssd_iter_140000.caffemodel');
+
+  if (!fs.existsSync(prototxt) || !fs.existsSync(modelFile)) {
+    console.log('could not find facenet model');
+    console.log('download the prototxt from: https://raw.githubusercontent.com/opencv/opencv/master/samples/dnn/face_detector/deploy.prototxt');
+    console.log('download the model from: https://raw.githubusercontent.com/opencv/opencv_3rdparty/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel');
+    throw new Error('exiting');
+  }
+  return cv.readNetFromCaffe(prototxt, modelFile);
+};

examples/typed/asyncMatchFeatures.ts

@@ -0,0 +1,38 @@
+import * as cv from '../../../';
+
+export type Prediction = {
+  classLabel: number
+  confidence: number
+  rect: cv.Rect
+}
+
+export function extractResults (
+  outputBlob: cv.Mat,
+  imgDimensions: { rows: number, cols: number }
+): Prediction[] {
+  return Array(outputBlob.rows).fill(0)
+    .map((res, i) => {
+      const classLabel = outputBlob.at(i, 1);
+      const confidence = outputBlob.at(i, 2);
+      const bottomLeft = new cv.Point2(
+        outputBlob.at(i, 3) * imgDimensions.cols,
+        outputBlob.at(i, 6) * imgDimensions.rows
+      );
+      const topRight = new cv.Point2(
+        outputBlob.at(i, 5) * imgDimensions.cols,
+        outputBlob.at(i, 4) * imgDimensions.rows
+      );
+      const rect = new cv.Rect(
+        bottomLeft.x,
+        topRight.y,
+        topRight.x - bottomLeft.x,
+        bottomLeft.y - topRight.y
+      );
+
+      return ({
+        classLabel,
+        confidence,
+        rect
+      });
+    });
+};