@srsergio/taptapp-ar 1.0.13 → 1.0.15

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/dist/compiler/detector/crop-detector.js

@@ -24,11 +24,16 @@ class CropDetector {
     }
     detectMoving(input) {
         const imageData = input;
-        // loop a few locations around center
-        const dx = this.lastRandomIndex % 3;
-        const dy = Math.floor(this.lastRandomIndex / 3);
-        let startY = Math.floor(this.height / 2 - this.cropSize + (dy * this.cropSize) / 2);
-        let startX = Math.floor(this.width / 2 - this.cropSize + (dx * this.cropSize) / 2);
+        // Expanded to 5x5 grid (25 positions) for better coverage
+        const gridSize = 5;
+        const dx = this.lastRandomIndex % gridSize;
+        const dy = Math.floor(this.lastRandomIndex / gridSize);
+        // Calculate offset from center, with overlap for better detection
+        const stepX = this.cropSize / 3;
+        const stepY = this.cropSize / 3;
+        let startY = Math.floor(this.height / 2 - this.cropSize / 2 + (dy - 2) * stepY);
+        let startX = Math.floor(this.width / 2 - this.cropSize / 2 + (dx - 2) * stepX);
+        // Clamp to valid bounds
         if (startX < 0)
             startX = 0;
         if (startY < 0)
@@ -37,7 +42,7 @@ class CropDetector {
             startX = this.width - this.cropSize - 1;
         if (startY >= this.height - this.cropSize)
             startY = this.height - this.cropSize - 1;
-        this.lastRandomIndex = (this.lastRandomIndex + 1) % 9;
+        this.lastRandomIndex = (this.lastRandomIndex + 1) % (gridSize * gridSize);
         const result = this._detect(imageData, startX, startY);
         return result;
     }

package/dist/compiler/simple-ar.js

@@ -152,11 +152,14 @@ class SimpleAR {
         // Matrix is column-major: [m0,m1,m2,m3, m4,m5,m6,m7, m8,m9,m10,m11, m12,m13,m14,m15]
         const tx = worldMatrix[12];
         const ty = worldMatrix[13];
-        const scale = Math.sqrt(worldMatrix[0] ** 2 + worldMatrix[1] ** 2);
+        const matrixScale = Math.sqrt(worldMatrix[0] ** 2 + worldMatrix[1] ** 2);
         const rotation = Math.atan2(worldMatrix[1], worldMatrix[0]);
         // Convert from normalized coords to screen coords
         const screenX = offsetX + (videoW / 2 + tx) * scaleX;
         const screenY = offsetY + (videoH / 2 - ty) * scaleY;
+        // Scale factor: use a reasonable multiplier (0.5 instead of 0.01)
+        // The matrixScale from the tracking is in image-space coordinates
+        const finalScale = matrixScale * scaleX * 0.5;
         // Apply transform
         this.overlay.style.position = 'absolute';
         this.overlay.style.transformOrigin = 'center center';
@@ -165,7 +168,7 @@ class SimpleAR {
         this.overlay.style.transform = `
       translate(${screenX}px, ${screenY}px)
       translate(-50%, -50%)
-      scale(${scale * scaleX * 0.01})
+      scale(${finalScale})
       rotate(${-rotation}rad)
     `;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "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];
 

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

@@ -33,19 +33,25 @@ class CropDetector {
   detectMoving(input) {
     const imageData = input;
 
-    // loop a few locations around center
-    const dx = this.lastRandomIndex % 3;
-    const dy = Math.floor(this.lastRandomIndex / 3);
+    // Expanded to 5x5 grid (25 positions) for better coverage
+    const gridSize = 5;
+    const dx = this.lastRandomIndex % gridSize;
+    const dy = Math.floor(this.lastRandomIndex / gridSize);
 
-    let startY = Math.floor(this.height / 2 - this.cropSize + (dy * this.cropSize) / 2);
-    let startX = Math.floor(this.width / 2 - this.cropSize + (dx * this.cropSize) / 2);
+    // Calculate offset from center, with overlap for better detection
+    const stepX = this.cropSize / 3;
+    const stepY = this.cropSize / 3;
 
+    let startY = Math.floor(this.height / 2 - this.cropSize / 2 + (dy - 2) * stepY);
+    let startX = Math.floor(this.width / 2 - this.cropSize / 2 + (dx - 2) * stepX);
+
+    // Clamp to valid bounds
     if (startX < 0) startX = 0;
     if (startY < 0) startY = 0;
     if (startX >= this.width - this.cropSize) startX = this.width - this.cropSize - 1;
     if (startY >= this.height - this.cropSize) startY = this.height - this.cropSize - 1;
 
-    this.lastRandomIndex = (this.lastRandomIndex + 1) % 9;
+    this.lastRandomIndex = (this.lastRandomIndex + 1) % (gridSize * gridSize);
 
     const result = this._detect(imageData, startX, startY);
     return result;

package/src/compiler/simple-ar.js

@@ -179,13 +179,17 @@ class SimpleAR {
         // Matrix is column-major: [m0,m1,m2,m3, m4,m5,m6,m7, m8,m9,m10,m11, m12,m13,m14,m15]
         const tx = worldMatrix[12];
         const ty = worldMatrix[13];
-        const scale = Math.sqrt(worldMatrix[0] ** 2 + worldMatrix[1] ** 2);
+        const matrixScale = Math.sqrt(worldMatrix[0] ** 2 + worldMatrix[1] ** 2);
         const rotation = Math.atan2(worldMatrix[1], worldMatrix[0]);
 
         // Convert from normalized coords to screen coords
         const screenX = offsetX + (videoW / 2 + tx) * scaleX;
         const screenY = offsetY + (videoH / 2 - ty) * scaleY;
 
+        // Scale factor: use a reasonable multiplier (0.5 instead of 0.01)
+        // The matrixScale from the tracking is in image-space coordinates
+        const finalScale = matrixScale * scaleX * 0.5;
+
         // Apply transform
         this.overlay.style.position = 'absolute';
         this.overlay.style.transformOrigin = 'center center';
@@ -194,7 +198,7 @@ class SimpleAR {
         this.overlay.style.transform = `
       translate(${screenX}px, ${screenY}px)
       translate(-50%, -50%)
-      scale(${scale * scaleX * 0.01})
+      scale(${finalScale})
       rotate(${-rotation}rad)
     `;
     }