@srsergio/taptapp-ar 1.0.13 → 1.0.14

package/dist/compiler/controller.d.ts

@@ -51,6 +51,7 @@ export class Controller {
         trackingDataList: any[];
     };
     tracker: Tracker | undefined;
+    matchingDataList: any[] | undefined;
     /**
      * Load image targets from a single ArrayBuffer (backward compatible)
      * @param {ArrayBuffer} buffer - Single .mind file buffer
@@ -100,8 +101,18 @@ export class Controller {
     trackUpdate(modelViewTransform: any, trackFeatures: any): Promise<any>;
     _workerMatch(featurePoints: any, targetIndexes: any): Promise<any>;
     workerMatchDone: ((data: any) => void) | undefined;
+    _matchOnMainThread(featurePoints: any, targetIndexes: any): Promise<{
+        targetIndex: number;
+        modelViewTransform: number[][] | null;
+        debugExtra: {
+            frames: never[];
+        } | null;
+    }>;
+    mainThreadMatcher: import("./matching/matcher.js").Matcher | undefined;
+    mainThreadEstimator: import("./estimation/estimator.js").Estimator | undefined;
     _workerTrackUpdate(modelViewTransform: any, trackingFeatures: any): Promise<any>;
     workerTrackDone: ((data: any) => void) | undefined;
+    _trackUpdateOnMainThread(modelViewTransform: any, trackingFeatures: any): Promise<never[][] | null>;
     _glModelViewMatrix(modelViewTransform: any, targetIndex: any): any[];
     _glProjectionMatrix({ projectionTransform, width, height, near, far }: {
         projectionTransform: any;

package/dist/compiler/controller.js

@@ -120,6 +120,7 @@ class Controller {
             });
         }
         this.markerDimensions = allDimensions;
+        this.matchingDataList = allMatchingData; // Store for main-thread fallback
         return { dimensions: allDimensions, matchingDataList: allMatchingData, trackingDataList: allTrackingData };
     }
     /**
@@ -324,6 +325,11 @@ class Controller {
     }
     _workerMatch(featurePoints, targetIndexes) {
         return new Promise((resolve) => {
+            // If no worker available, process on main thread
+            if (!this.worker) {
+                this._matchOnMainThread(featurePoints, targetIndexes).then(resolve);
+                return;
+            }
             this.workerMatchDone = (data) => {
                 resolve({
                     targetIndex: data.targetIndex,
@@ -331,16 +337,51 @@ class Controller {
                     debugExtra: data.debugExtra,
                 });
             };
-            this.worker && this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
+            this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
         });
     }
+    async _matchOnMainThread(featurePoints, targetIndexes) {
+        // Lazy initialize Matcher and Estimator for main thread
+        if (!this.mainThreadMatcher) {
+            const { Matcher } = await import("./matching/matcher.js");
+            const { Estimator } = await import("./estimation/estimator.js");
+            this.mainThreadMatcher = new Matcher(this.inputWidth, this.inputHeight, this.debugMode);
+            this.mainThreadEstimator = new Estimator(this.projectionTransform);
+        }
+        let matchedTargetIndex = -1;
+        let matchedModelViewTransform = null;
+        let matchedDebugExtra = null;
+        for (let i = 0; i < targetIndexes.length; i++) {
+            const matchingIndex = targetIndexes[i];
+            const { keyframeIndex, screenCoords, worldCoords, debugExtra } = this.mainThreadMatcher.matchDetection(this.matchingDataList[matchingIndex], featurePoints);
+            matchedDebugExtra = debugExtra;
+            if (keyframeIndex !== -1) {
+                const modelViewTransform = this.mainThreadEstimator.estimate({ screenCoords, worldCoords });
+                if (modelViewTransform) {
+                    matchedTargetIndex = matchingIndex;
+                    matchedModelViewTransform = modelViewTransform;
+                }
+                break;
+            }
+        }
+        return {
+            targetIndex: matchedTargetIndex,
+            modelViewTransform: matchedModelViewTransform,
+            debugExtra: matchedDebugExtra,
+        };
+    }
     _workerTrackUpdate(modelViewTransform, trackingFeatures) {
         return new Promise((resolve) => {
+            // If no worker available, process on main thread
+            if (!this.worker) {
+                this._trackUpdateOnMainThread(modelViewTransform, trackingFeatures).then(resolve);
+                return;
+            }
             this.workerTrackDone = (data) => {
                 resolve(data.modelViewTransform);
             };
             const { worldCoords, screenCoords } = trackingFeatures;
-            this.worker && this.worker.postMessage({
+            this.worker.postMessage({
                 type: "trackUpdate",
                 modelViewTransform,
                 worldCoords,
@@ -348,6 +389,20 @@ class Controller {
             });
         });
     }
+    async _trackUpdateOnMainThread(modelViewTransform, trackingFeatures) {
+        // Lazy initialize Estimator for main thread
+        if (!this.mainThreadEstimator) {
+            const { Estimator } = await import("./estimation/estimator.js");
+            this.mainThreadEstimator = new Estimator(this.projectionTransform);
+        }
+        const { worldCoords, screenCoords } = trackingFeatures;
+        const finalModelViewTransform = this.mainThreadEstimator.refineEstimate({
+            initialModelViewTransform: modelViewTransform,
+            worldCoords,
+            screenCoords,
+        });
+        return finalModelViewTransform;
+    }
     _glModelViewMatrix(modelViewTransform, targetIndex) {
         const height = this.markerDimensions[targetIndex][1];
         const openGLWorldMatrix = [

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.13",
+    "version": "1.0.14",
     "description": "AR Compiler for Node.js and Browser",
     "repository": {
         "type": "git",

package/src/compiler/controller.js

@@ -153,6 +153,7 @@ class Controller {
     }
 
     this.markerDimensions = allDimensions;
+    this.matchingDataList = allMatchingData; // Store for main-thread fallback
     return { dimensions: allDimensions, matchingDataList: allMatchingData, trackingDataList: allTrackingData };
   }
 
@@ -395,6 +396,12 @@ class Controller {
 
   _workerMatch(featurePoints, targetIndexes) {
     return new Promise((resolve) => {
+      // If no worker available, process on main thread
+      if (!this.worker) {
+        this._matchOnMainThread(featurePoints, targetIndexes).then(resolve);
+        return;
+      }
+
       this.workerMatchDone = (data) => {
         resolve({
           targetIndex: data.targetIndex,
@@ -402,17 +409,63 @@ class Controller {
           debugExtra: data.debugExtra,
         });
       };
-      this.worker && this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
+      this.worker.postMessage({ type: "match", featurePoints: featurePoints, targetIndexes });
     });
   }
 
+  async _matchOnMainThread(featurePoints, targetIndexes) {
+    // Lazy initialize Matcher and Estimator for main thread
+    if (!this.mainThreadMatcher) {
+      const { Matcher } = await import("./matching/matcher.js");
+      const { Estimator } = await import("./estimation/estimator.js");
+      this.mainThreadMatcher = new Matcher(this.inputWidth, this.inputHeight, this.debugMode);
+      this.mainThreadEstimator = new Estimator(this.projectionTransform);
+    }
+
+    let matchedTargetIndex = -1;
+    let matchedModelViewTransform = null;
+    let matchedDebugExtra = null;
+
+    for (let i = 0; i < targetIndexes.length; i++) {
+      const matchingIndex = targetIndexes[i];
+
+      const { keyframeIndex, screenCoords, worldCoords, debugExtra } = this.mainThreadMatcher.matchDetection(
+        this.matchingDataList[matchingIndex],
+        featurePoints,
+      );
+      matchedDebugExtra = debugExtra;
+
+      if (keyframeIndex !== -1) {
+        const modelViewTransform = this.mainThreadEstimator.estimate({ screenCoords, worldCoords });
+
+        if (modelViewTransform) {
+          matchedTargetIndex = matchingIndex;
+          matchedModelViewTransform = modelViewTransform;
+        }
+        break;
+      }
+    }
+
+    return {
+      targetIndex: matchedTargetIndex,
+      modelViewTransform: matchedModelViewTransform,
+      debugExtra: matchedDebugExtra,
+    };
+  }
+
   _workerTrackUpdate(modelViewTransform, trackingFeatures) {
     return new Promise((resolve) => {
+      // If no worker available, process on main thread
+      if (!this.worker) {
+        this._trackUpdateOnMainThread(modelViewTransform, trackingFeatures).then(resolve);
+        return;
+      }
+
       this.workerTrackDone = (data) => {
         resolve(data.modelViewTransform);
       };
       const { worldCoords, screenCoords } = trackingFeatures;
-      this.worker && this.worker.postMessage({
+      this.worker.postMessage({
         type: "trackUpdate",
         modelViewTransform,
         worldCoords,
@@ -421,6 +474,22 @@ class Controller {
     });
   }
 
+  async _trackUpdateOnMainThread(modelViewTransform, trackingFeatures) {
+    // Lazy initialize Estimator for main thread
+    if (!this.mainThreadEstimator) {
+      const { Estimator } = await import("./estimation/estimator.js");
+      this.mainThreadEstimator = new Estimator(this.projectionTransform);
+    }
+
+    const { worldCoords, screenCoords } = trackingFeatures;
+    const finalModelViewTransform = this.mainThreadEstimator.refineEstimate({
+      initialModelViewTransform: modelViewTransform,
+      worldCoords,
+      screenCoords,
+    });
+    return finalModelViewTransform;
+  }
+
   _glModelViewMatrix(modelViewTransform, targetIndex) {
     const height = this.markerDimensions[targetIndex][1];