@srsergio/taptapp-ar 1.0.2 → 1.0.4

package/dist/compiler/utils/worker-pool.js

@@ -0,0 +1,84 @@
+import { Worker } from 'node:worker_threads';
+import os from 'node:os';
+export class WorkerPool {
+    constructor(workerPath, poolSize = os.cpus().length) {
+        this.workerPath = workerPath;
+        this.poolSize = poolSize;
+        this.workers = [];
+        this.queue = [];
+        this.activeWorkers = 0;
+    }
+    runTask(taskData) {
+        return new Promise((resolve, reject) => {
+            const task = { taskData, resolve, reject };
+            if (this.workers.length > 0) {
+                this._executeTask(this.workers.pop(), task);
+            }
+            else if (this.activeWorkers < this.poolSize) {
+                this._executeTask(this._createWorker(), task);
+            }
+            else {
+                this.queue.push(task);
+            }
+        });
+    }
+    _createWorker() {
+        this.activeWorkers++;
+        const worker = new Worker(this.workerPath);
+        return worker;
+    }
+    _executeTask(worker, task) {
+        const onMessage = (msg) => {
+            if (msg.type === 'progress' && task.taskData.onProgress) {
+                task.taskData.onProgress(msg.percent);
+            }
+            else if (msg.type === 'compileDone') {
+                cleanup();
+                this._finishTask(worker, task.resolve, msg.trackingData);
+            }
+            else if (msg.type === 'matchDone') {
+                cleanup();
+                this._finishTask(worker, task.resolve, msg.matchingData);
+            }
+            else if (msg.type === 'error') {
+                cleanup();
+                this._finishTask(worker, task.reject, new Error(msg.error));
+            }
+        };
+        const onError = (err) => {
+            cleanup();
+            this._finishTask(worker, task.reject, err);
+        };
+        const cleanup = () => {
+            worker.removeListener('message', onMessage);
+            worker.removeListener('error', onError);
+        };
+        worker.on('message', onMessage);
+        worker.on('error', onError);
+        // Create a copy of taskData without functions for the worker
+        const serializableData = {};
+        for (const [key, value] of Object.entries(task.taskData)) {
+            if (typeof value !== 'function') {
+                serializableData[key] = value;
+            }
+        }
+        worker.postMessage({
+            type: 'compile',
+            ...serializableData
+        });
+    }
+    _finishTask(worker, callback, result) {
+        if (this.queue.length > 0) {
+            this._executeTask(worker, this.queue.shift());
+        }
+        else {
+            this.workers.push(worker);
+        }
+        callback(result);
+    }
+    async destroy() {
+        await Promise.all(this.workers.map(w => w.terminate()));
+        this.workers = [];
+        this.activeWorkers = 0;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.2",
+    "version": "1.0.4",
     "description": "AR Visualizer and Compiler for Astro and React",
     "repository": {
         "type": "git",
@@ -29,33 +29,31 @@
     ],
     "scripts": {
         "build": "tsc",
-        "prepublishOnly": "npm run build"
+        "prepublishOnly": "npm run build",
+        "test": "vitest"
     },
     "peerDependencies": {
+        "aframe": ">=1.5.0",
         "astro": ">=4.0.0",
         "react": ">=18.0.0",
         "react-dom": ">=18.0.0",
-        "three": ">=0.160.0",
-        "aframe": ">=1.5.0"
+        "three": ">=0.160.0"
     },
     "dependencies": {
-        "@tensorflow/tfjs": "^4.22.0",
-        "@tensorflow/tfjs-backend-cpu": "^4.22.0",
-        "@tensorflow/tfjs-backend-webgl": "^4.22.0",
+        "gpu.js": "^2.16.0",
         "ml-matrix": "^6.10.4",
-        "svd-js": "^1.1.1",
-        "tinyqueue": "^2.0.3",
-        "lucide-react": "^0.477.0",
-        "nanoid": "^5.0.7"
+        "tinyqueue": "^2.0.3"
     },
     "devDependencies": {
-        "typescript": "^5.4.5",
         "@types/react": "^18.3.3",
         "@types/react-dom": "^18.3.0",
         "@types/three": "^0.170.0",
-        "astro": "5.16.4"
+        "astro": "5.16.4",
+        "jimp": "^1.6.0",
+        "typescript": "^5.4.5",
+        "vitest": "^4.0.16"
     },
     "publishConfig": {
         "access": "public"
     }
-}
+}

package/src/compiler/aframe.js

@@ -1,6 +1,6 @@
 import { Controller, UI } from "./index.js";
 
-const needsDOMRefresh = document.readyState === "complete" || document.readyState == "interactive";
+
 AFRAME.registerSystem("mindar-image-system", {
   container: null,
   video: null,
@@ -10,7 +10,7 @@ AFRAME.registerSystem("mindar-image-system", {
     this.anchorEntities = [];
   },
 
-  tick: function () {},
+  tick: function () { },
 
   setup: function ({
     imageTargetSrc,
@@ -121,7 +121,6 @@ AFRAME.registerSystem("mindar-image-system", {
 
   _startAR: async function () {
     const video = this.video;
-    const container = this.container;
 
     this.controller = new Controller({
       inputWidth: video.videoWidth,
@@ -196,7 +195,6 @@ AFRAME.registerSystem("mindar-image-system", {
     const fov = (2 * Math.atan((1 / proj[5] / vh) * container.clientHeight) * 180) / Math.PI; // vertical fov
     const near = proj[14] / (proj[10] - 1.0);
     const far = proj[14] / (proj[10] + 1.0);
-    const ratio = proj[5] / proj[0]; // (r-l) / (t-b)
     //console.log("loaded proj: ", proj, ". fov: ", fov, ". near: ", near, ". far: ", far, ". ratio: ", ratio);
     const newAspect = container.clientWidth / container.clientHeight;
     const cameraEle = container.getElementsByTagName("a-camera")[0];

package/src/compiler/compiler-base.js

@@ -65,21 +65,35 @@ class CompilerBase {
         }
 
         // compute matching data: 50% progress
-        const percentPerImage = 50.0 / targetImages.length;
-        let percent = 0.0;
+        let matchingDataList;
+        if (this.compileMatch) {
+          matchingDataList = await this.compileMatch({
+            progressCallback,
+            targetImages,
+            basePercent: 0,
+          });
+        } else {
+          const percentPerImage = 50.0 / targetImages.length;
+          let percent = 0.0;
+          const matchingPromises = targetImages.map(async (targetImage, i) => {
+            const imageList = buildImageList(targetImage);
+            const percentPerAction = percentPerImage / imageList.length;
+
+            const matchingData = await _extractMatchingFeatures(imageList, () => {
+              percent += percentPerAction;
+              progressCallback(percent);
+            });
+            return matchingData;
+          });
+          matchingDataList = await Promise.all(matchingPromises);
+        }
+
         this.data = [];
         for (let i = 0; i < targetImages.length; i++) {
-          const targetImage = targetImages[i];
-          const imageList = buildImageList(targetImage);
-          const percentPerAction = percentPerImage / imageList.length;
-          const matchingData = await _extractMatchingFeatures(imageList, () => {
-            percent += percentPerAction;
-            progressCallback(percent);
-          });
           this.data.push({
-            targetImage: targetImage,
-            imageList: imageList,
-            matchingData: matchingData,
+            targetImage: targetImages[i],
+            imageList: buildImageList(targetImages[i]),
+            matchingData: matchingDataList[i],
           });
         }
 
@@ -145,14 +159,15 @@ class CompilerBase {
     return this.data;
   }
 
-  createProcessCanvas(img) {
+  createProcessCanvas() {
     // sub-class implements
     console.warn("missing createProcessCanvas implementation");
   }
 
-  compileTrack({ progressCallback, targetImages, basePercent }) {
+  compileTrack() {
     // sub-class implements
     console.warn("missing compileTrack implementation");
+    return Promise.resolve([]);
   }
 }
 

package/src/compiler/compiler.js

@@ -10,7 +10,7 @@ export class Compiler extends CompilerBase {
   }
 
   compileTrack({ progressCallback, targetImages, basePercent }) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       const worker = new CompilerWorker();
       worker.onmessage = (e) => {
         if (e.data.type === "progress") {

package/src/compiler/compiler.worker.js

@@ -15,7 +15,7 @@ onmessage = (msg) => {
       const percentPerAction = percentPerImage / imageList.length;
 
       //console.log("compiling tracking...", i);
-      const trackingData = extractTrackingFeatures(imageList, (index) => {
+      const trackingData = extractTrackingFeatures(imageList, () => {
         //console.log("done tracking", i, index);
         percent += percentPerAction;
         postMessage({ type: "progress", percent });

package/src/compiler/controller.js

@@ -81,7 +81,7 @@ class Controller {
   }
 
   addImageTargets(fileURL) {
-    return new Promise(async (resolve, reject) => {
+    return new Promise(async (resolve) => {
       const content = await fetch(fileURL);
       const buffer = await content.arrayBuffer();
       const result = this.addImageTargetsFromBuffer(buffer);
@@ -95,7 +95,6 @@ class Controller {
 
     const trackingDataList = [];
     const matchingDataList = [];
-    const imageListList = [];
     const dimensions = [];
     for (let i = 0; i < dataList.length; i++) {
       matchingDataList.push(dataList[i].matchingData);
@@ -329,7 +328,7 @@ class Controller {
 
   async detect(input) {
     const inputT = this.inputLoader.loadInput(input);
-    const { featurePoints, debugExtra } = await this.cropDetector.detect(inputT);
+    const { featurePoints, debugExtra } = this.cropDetector.detect(inputT);
     inputT.dispose();
     return { featurePoints, debugExtra };
   }
@@ -355,7 +354,7 @@ class Controller {
   }
 
   _workerMatch(featurePoints, targetIndexes) {
-    return new Promise(async (resolve, reject) => {
+    return new Promise((resolve) => {
       this.workerMatchDone = (data) => {
         resolve({
           targetIndex: data.targetIndex,
@@ -368,7 +367,7 @@ class Controller {
   }
 
   _workerTrackUpdate(modelViewTransform, trackingFeatures) {
-    return new Promise(async (resolve, reject) => {
+    return new Promise((resolve) => {
       this.workerTrackDone = (data) => {
         resolve(data.modelViewTransform);
       };

package/src/compiler/controller.worker.js

@@ -1,7 +1,6 @@
 import { Matcher } from "./matching/matcher.js";
 import { Estimator } from "./estimation/estimator.js";
 
-let projectionTransform = null;
 let matchingDataList = null;
 let debugMode = false;
 let matcher = null;
@@ -12,7 +11,6 @@ onmessage = (msg) => {
 
   switch (data.type) {
     case "setup":
-      projectionTransform = data.projectionTransform;
       matchingDataList = data.matchingDataList;
       debugMode = data.debugMode;
       matcher = new Matcher(data.inputWidth, data.inputHeight, debugMode);

package/src/compiler/detector/crop-detector.js

@@ -1,6 +1,4 @@
-import * as tf from "@tensorflow/tfjs";
 import { Detector } from "./detector.js";
-import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
 
 class CropDetector {
   constructor(width, height, debugMode = false) {