update samples

CHANGELOG.md

@@ -9,7 +9,7 @@
   
 ## Changelog
   
-### **HEAD -> main** 2022/09/14 mandic00@live.com
+### **HEAD -> main** 2022/09/17 mandic00@live.com
 
 
 ### **2.10.2** 2022/09/11 mandic00@live.com

TODO.md

@@ -48,3 +48,5 @@ Enable via `about:config` -> `gfx.offscreencanvas.enabled`
 - New simple demo [*Live*](https://vladmandic.github.io/human/demo/video/index.html)
 - Enable model cache when using web workers  
 - Improve NodeJS resolver when using ESM  
+- Update demo `demo/nodejs/process-folder.js`  
+  and re-process `/samples`

demo/multithread/node-multiprocess.js

@@ -13,7 +13,7 @@ const childProcess = require('child_process'); // eslint-disable-line camelcase
 // note that main process does not import human or tfjs at all, it's all done from worker process
 
 const workerFile = 'demo/multithread/node-multiprocess-worker.js';
-const imgPathRoot = './assets'; // modify to include your sample images
+const imgPathRoot = './samples/in'; // modify to include your sample images
 const numWorkers = 4; // how many workers will be started
 const workers = []; // this holds worker processes
 const images = []; // this holds queue of enumerated images
@@ -22,7 +22,7 @@ let numImages;
 
 // trigered by main when worker sends ready message
 // if image pool is empty, signal worker to exit otherwise dispatch image to worker and remove image from queue
-async function detect(worker) {
+async function submitDetect(worker) {
   if (!t[2]) t[2] = process.hrtime.bigint(); // first time do a timestamp so we can measure initial latency
   if (images.length === numImages) worker.send({ test: true }); // for first image in queue just measure latency
   if (images.length === 0) worker.send({ exit: true }); // nothing left in queue
@@ -79,7 +79,7 @@ async function main() {
     // if message is processing result, just print how many faces were detected
     // otherwise it's an unknown message
     workers[i].on('message', (msg) => {
-      if (msg.ready) detect(workers[i]);
+      if (msg.ready) submitDetect(workers[i]);
       else if (msg.image) log.data('Main: worker finished:', workers[i].pid, 'detected faces:', msg.detected.face?.length, 'bodies:', msg.detected.body?.length, 'hands:', msg.detected.hand?.length, 'objects:', msg.detected.object?.length);
       else if (msg.test) measureLatency();
       else log.data('Main: worker message:', workers[i].pid, msg);

demo/nodejs/node-canvas.js

@@ -15,8 +15,8 @@ const Human = require('../../dist/human.node.js'); // use this when using human
 
 const config = { // just enable all and leave default settings
   debug: false,
-  face: { enabled: true }, // includes mesh, iris, emotion, descriptor
-  hand: { enabled: true, maxDetected: 2, minConfidence: 0.5, detector: { modelPath: 'handtrack.json' } }, // use alternative hand model
+  face: { enabled: true, detector: { maxDetected: 10 } }, // includes mesh, iris, emotion, descriptor
+  hand: { enabled: true, maxDetected: 20, minConfidence: 0.5, detector: { modelPath: 'handtrack.json' } }, // use alternative hand model
   body: { enabled: true },
   object: { enabled: true },
   gestures: { enabled: true },

demo/nodejs/node-simple.js

@@ -12,6 +12,7 @@ const Human = require('../../dist/human.node.js'); // use this when using human
 
 const humanConfig = {
   // add any custom config here
+  debug: true,
 };
 
 async function detect(inputFile) {

demo/nodejs/process-folder.js

@@ -13,27 +13,69 @@ const process = require('process');
 const log = require('@vladmandic/pilogger'); // eslint-disable-line node/no-unpublished-require
 const canvas = require('canvas'); // eslint-disable-line node/no-unpublished-require
 // for nodejs, `tfjs-node` or `tfjs-node-gpu` should be loaded before using Human
-const tf = require('@tensorflow/tfjs-node'); // eslint-disable-line node/no-unpublished-require
+const tf = require('@tensorflow/tfjs-node-gpu'); // eslint-disable-line node/no-unpublished-require
 const Human = require('../../dist/human.node-gpu.js'); // this is 'const Human = require('../dist/human.node-gpu.js').default;'
 
 const config = { // just enable all and leave default settings
+  modelBasePath: 'file://models',
   debug: true,
-  async: false,
+  softwareKernels: true, // slower but enhanced precision since face rotation can work in software mode in nodejs environments
   cacheSensitivity: 0,
-  face: { enabled: true, detector: { maxDetected: 20 } },
-  object: { enabled: true },
+  face: { enabled: true, detector: { maxDetected: 100, minConfidence: 0.1 } },
+  object: { enabled: true, maxDetected: 100, minConfidence: 0.1 },
   gesture: { enabled: true },
-  hand: { enabled: true },
-  body: { enabled: true, modelPath: 'https://vladmandic.github.io/human-models/models/movenet-multipose.json' },
+  hand: { enabled: true, maxDetected: 100, minConfidence: 0.2 },
+  body: { enabled: true, maxDetected: 100, minConfidence: 0.1, modelPath: 'https://vladmandic.github.io/human-models/models/movenet-multipose.json' },
 };
 
+const poolSize = 4;
+
+const human = new Human.Human(config); // create instance of human
+
+async function saveFile(shape, buffer, result, outFile) {
+  return new Promise(async (resolve, reject) => { // eslint-disable-line no-async-promise-executor
+    const outputCanvas = new canvas.Canvas(shape[2], shape[1]); // create canvas
+    const outputCtx = outputCanvas.getContext('2d');
+    const inputImage = await canvas.loadImage(buffer); // load image using canvas library
+    outputCtx.drawImage(inputImage, 0, 0); // draw input image onto canvas
+    human.draw.all(outputCanvas, result); // use human build-in method to draw results as overlays on canvas
+    const outStream = fs.createWriteStream(outFile); // write canvas to new image file
+    outStream.on('finish', () => {
+      log.data('Output image:', outFile, outputCanvas.width, outputCanvas.height);
+      resolve();
+    });
+    outStream.on('error', (err) => {
+      log.error('Output error:', outFile, err);
+      reject();
+    });
+    const stream = outputCanvas.createJPEGStream({ quality: 0.5, progressive: true, chromaSubsampling: true });
+    stream.pipe(outStream);
+  });
+}
+
+async function processFile(image, inFile, outFile) {
+  const buffer = fs.readFileSync(inFile);
+  const tensor = tf.tidy(() => {
+    const decode = tf.node.decodeImage(buffer, 3);
+    const expand = tf.expandDims(decode, 0);
+    const cast = tf.cast(expand, 'float32');
+    return cast;
+  });
+  log.state('Loaded image:', inFile, tensor.shape);
+
+  const result = await human.detect(tensor);
+  human.tf.dispose(tensor);
+  log.data(`Detected: ${image}:`, 'Face:', result.face.length, 'Body:', result.body.length, 'Hand:', result.hand.length, 'Objects:', result.object.length, 'Gestures:', result.gesture.length);
+
+  if (outFile) await saveFile(tensor.shape, buffer, result, outFile);
+}
+
 async function main() {
   log.header();
 
   globalThis.Canvas = canvas.Canvas; // patch global namespace with canvas library
   globalThis.ImageData = canvas.ImageData; // patch global namespace with canvas library
 
-  const human = new Human.Human(config); // create instance of human
   log.info('Human:', human.version, 'TF:', tf.version_core);
   const configErrors = await human.validate();
   if (configErrors.length > 0) log.error('Configuration errors:', configErrors);
@@ -42,45 +84,36 @@ async function main() {
 
   const inDir = process.argv[2];
   const outDir = process.argv[3];
-  if (process.argv.length !== 4) {
-    log.error('Parameters: <input-directory> <output-directory> missing');
+  if (!inDir) {
+    log.error('Parameters: <input-directory> missing');
     return;
   }
-  if (!fs.existsSync(inDir) || !fs.statSync(inDir).isDirectory() || !fs.existsSync(outDir) || !fs.statSync(outDir).isDirectory()) {
-    log.error('Invalid directory specified:', 'input:', fs.existsSync(inDir) ?? fs.statSync(inDir).isDirectory(), 'output:', fs.existsSync(outDir) ?? fs.statSync(outDir).isDirectory());
+  if (inDir && (!fs.existsSync(inDir) || !fs.statSync(inDir).isDirectory())) {
+    log.error('Invalid input directory:', fs.existsSync(inDir) ?? fs.statSync(inDir).isDirectory());
+    return;
+  }
+  if (!outDir) {
+    log.info('Parameters: <output-directory> missing, images will not be saved');
+  }
+  if (outDir && (!fs.existsSync(outDir) || !fs.statSync(outDir).isDirectory())) {
+    log.error('Invalid output directory:', fs.existsSync(outDir) ?? fs.statSync(outDir).isDirectory());
     return;
   }
 
   const dir = fs.readdirSync(inDir);
   const images = dir.filter((f) => fs.statSync(path.join(inDir, f)).isFile() && (f.toLocaleLowerCase().endsWith('.jpg') || f.toLocaleLowerCase().endsWith('.jpeg')));
   log.info(`Processing folder: ${inDir} entries:`, dir.length, 'images', images.length);
-  for (const image of images) {
-    const inFile = path.join(inDir, image);
-    const buffer = fs.readFileSync(inFile);
-    const tensor = human.tf.tidy(() => {
-      const decode = human.tf.node.decodeImage(buffer, 3);
-      const expand = human.tf.expandDims(decode, 0);
-      const cast = human.tf.cast(expand, 'float32');
-      return cast;
-    });
-    log.state('Loaded image:', inFile, tensor.shape);
-
-    const result = await human.detect(tensor);
-    human.tf.dispose(tensor);
-    log.data(`Detected: ${image}:`, 'Face:', result.face.length, 'Body:', result.body.length, 'Hand:', result.hand.length, 'Objects:', result.object.length, 'Gestures:', result.gesture.length);
-
-    const outputCanvas = new canvas.Canvas(tensor.shape[2], tensor.shape[1]); // create canvas
-    const outputCtx = outputCanvas.getContext('2d');
-    const inputImage = await canvas.loadImage(buffer); // load image using canvas library
-    outputCtx.drawImage(inputImage, 0, 0); // draw input image onto canvas
-    human.draw.all(outputCanvas, result); // use human build-in method to draw results as overlays on canvas
-    const outFile = path.join(outDir, image);
-    const outStream = fs.createWriteStream(outFile); // write canvas to new image file
-    outStream.on('finish', () => log.state('Output image:', outFile, outputCanvas.width, outputCanvas.height));
-    outStream.on('error', (err) => log.error('Output error:', outFile, err));
-    const stream = outputCanvas.createJPEGStream({ quality: 0.5, progressive: true, chromaSubsampling: true });
-    stream.pipe(outStream);
+  const t0 = performance.now();
+  const promises = [];
+  for (let i = 0; i < images.length; i++) {
+    const inFile = path.join(inDir, images[i]);
+    const outFile = outDir ? path.join(outDir, images[i]) : null;
+    promises.push(processFile(images[i], inFile, outFile));
+    if (i % poolSize === 0) await Promise.all(promises);
   }
+  await Promise.all(promises);
+  const t1 = performance.now();
+  log.info(`Processed ${images.length} images in ${Math.round(t1 - t0)} ms`);
 }
 
 main();

package.json

@@ -90,7 +90,7 @@
     "@vladmandic/tfjs": "github:vladmandic/tfjs",
     "@webgpu/types": "^0.1.21",
     "canvas": "^2.10.1",
-    "esbuild": "^0.15.7",
+    "esbuild": "^0.15.8",
     "eslint": "8.23.1",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-html": "^7.1.0",
@@ -102,7 +102,7 @@
     "rimraf": "^3.0.2",
     "seedrandom": "^3.0.5",
     "tslib": "^2.4.0",
-    "typedoc": "0.23.14",
+    "typedoc": "0.23.15",
     "typescript": "4.8.3"
   }
 }