@srsergio/taptapp-ar 1.0.74 → 1.0.76

package/dist/compiler/controller.js

@@ -18,10 +18,10 @@ const getControllerWorker = async () => {
     }
 };
 ControllerWorker = await getControllerWorker();
-const DEFAULT_FILTER_CUTOFF = 1.0;
+const DEFAULT_FILTER_CUTOFF = 0.5;
 const DEFAULT_FILTER_BETA = 0.1;
-const DEFAULT_WARMUP_TOLERANCE = 8;
-const DEFAULT_MISS_TOLERANCE = 2;
+const DEFAULT_WARMUP_TOLERANCE = 2; // Instant detection
+const DEFAULT_MISS_TOLERANCE = 5; // More grace when partially hidden
 class Controller {
     inputWidth;
     inputHeight;

package/dist/compiler/detector/crop-detector.d.ts

@@ -22,9 +22,6 @@ export class CropDetector {
             projectedImage?: undefined;
         };
     };
-    /**
-     * Scans the ENTIRE frame by downsampling it to cropSize
-     */
     _detectGlobal(imageData: any): {
         featurePoints: any[];
         debugExtra: {

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

@@ -24,16 +24,16 @@ class CropDetector {
     }
     detectMoving(input) {
         const imageData = input;
-        // 🚀 MOONSHOT: Alternate between local crops and GLOBAL scan
-        // This solves the "not reading the whole screen" issue.
-        // Every 3 frames, we do a full screen downsampled scan.
-        if (this.lastRandomIndex % 3 === 0) {
+        // 🚀 MOONSHOT: High Frequency Global Scan
+        // Scan full screen every 2 frames when searching to guarantee instant recovery
+        if (this.lastRandomIndex % 2 === 0) {
             this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
             return this._detectGlobal(imageData);
         }
-        // Original moving crop logic for high-detail local detection
+        // Local crops (25 grid)
         const gridSize = 5;
         const idx = (this.lastRandomIndex - 1) % (gridSize * gridSize);
+        // ... rest of logic remains but we hit it less often because global scan is more successful
         const dx = idx % gridSize;
         const dy = Math.floor(idx / gridSize);
         const stepX = this.cropSize / 3;
@@ -45,19 +45,18 @@ class CropDetector {
         this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
         return this._detect(imageData, startX, startY);
     }
-    /**
-     * Scans the ENTIRE frame by downsampling it to cropSize
-     */
     _detectGlobal(imageData) {
         const croppedData = new Float32Array(this.cropSize * this.cropSize);
         const scaleX = this.width / this.cropSize;
         const scaleY = this.height / this.cropSize;
-        // Fast downsample (nearest neighbor is enough for initial feature detection)
+        // Better sampling: avoid missing edges by jumping too much
         for (let y = 0; y < this.cropSize; y++) {
             const srcY = Math.floor(y * scaleY) * this.width;
             const dstY = y * this.cropSize;
             for (let x = 0; x < this.cropSize; x++) {
-                croppedData[dstY + x] = imageData[srcY + Math.floor(x * scaleX)];
+                // Average slightly to preserve gradients
+                const sx = Math.floor(x * scaleX);
+                croppedData[dstY + x] = (imageData[srcY + sx] + imageData[srcY + sx + 1]) * 0.5;
             }
         }
         const { featurePoints } = this.detector.detect(croppedData);

package/dist/compiler/simple-ar.js

@@ -123,7 +123,7 @@ class SimpleAR {
             }
             this.lastMatrix = worldMatrix;
             if (!this.filters[targetIndex]) {
-                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 1.0, beta: 0.1 });
+                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 0.8, beta: 0.2 });
             }
             const flatMVT = [
                 modelViewTransform[0][0], modelViewTransform[0][1], modelViewTransform[0][2], modelViewTransform[0][3],

package/dist/compiler/tracker/tracker.js

@@ -165,18 +165,18 @@ class Tracker {
                 matchingPoints.push([bestX, bestY]);
                 continue;
             }
-            // Search in projected image
-            for (let sy = -searchOneSize; sy <= searchOneSize; sy += searchGap) {
+            // 🚀 MOONSHOT: Coarse-to-Fine Search for MAXIMUM FPS
+            // Step 1: Coarse search (Gap 4)
+            const coarseGap = 4;
+            for (let sy = -searchOneSize; sy <= searchOneSize; sy += coarseGap) {
                 const cy = sCenterY + sy;
                 if (cy < templateOneSize || cy >= markerHeight - templateOneSize)
                     continue;
-                for (let sx = -searchOneSize; sx <= searchOneSize; sx += searchGap) {
+                for (let sx = -searchOneSize; sx <= searchOneSize; sx += coarseGap) {
                     const cx = sCenterX + sx;
                     if (cx < templateOneSize || cx >= markerWidth - templateOneSize)
                         continue;
-                    let sumI = 0;
-                    let sumI2 = 0;
-                    let sumIT = 0;
+                    let sumI = 0, sumI2 = 0, sumIT = 0;
                     for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
                         const rowOffset = (cy + ty) * markerWidth;
                         const tRowOffset = (ty + templateOneSize) * templateSize;
@@ -199,6 +199,43 @@ class Tracker {
                     }
                 }
             }
+            // Step 2: Fine refinement (Gap 1) only around the best coarse match
+            if (bestSim > AR2_SIM_THRESH) {
+                const fineCenterX = (bestX * scale) | 0;
+                const fineCenterY = (bestY * scale) | 0;
+                const fineSearch = coarseGap;
+                for (let sy = -fineSearch; sy <= fineSearch; sy++) {
+                    const cy = fineCenterY + sy;
+                    if (cy < templateOneSize || cy >= markerHeight - templateOneSize)
+                        continue;
+                    for (let sx = -fineSearch; sx <= fineSearch; sx++) {
+                        const cx = fineCenterX + sx;
+                        if (cx < templateOneSize || cx >= markerWidth - templateOneSize)
+                            continue;
+                        let sumI = 0, sumI2 = 0, sumIT = 0;
+                        for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
+                            const rowOffset = (cy + ty) * markerWidth;
+                            const tRowOffset = (ty + templateOneSize) * templateSize;
+                            for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
+                                const valI = projectedImage[rowOffset + (cx + tx)];
+                                const valT = templateData[tRowOffset + (tx + templateOneSize)];
+                                sumI += valI;
+                                sumI2 += valI * valI;
+                                sumIT += valI * valT;
+                            }
+                        }
+                        const varI = Math.sqrt(Math.max(0, sumI2 - (sumI * sumI) * oneOverNPixels));
+                        if (varI < 0.0001)
+                            continue;
+                        const sim = (sumIT - (sumI * sumT) * oneOverNPixels) / (varI * varT);
+                        if (sim > bestSim) {
+                            bestSim = sim;
+                            bestX = cx / scale;
+                            bestY = cy / scale;
+                        }
+                    }
+                }
+            }
             sims[f] = bestSim;
             matchingPoints.push([bestX, bestY]);
         }

package/package.json

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

package/src/compiler/controller.ts

@@ -19,10 +19,10 @@ const getControllerWorker = async () => {
 };
 ControllerWorker = await getControllerWorker();
 
-const DEFAULT_FILTER_CUTOFF = 1.0;
+const DEFAULT_FILTER_CUTOFF = 0.5;
 const DEFAULT_FILTER_BETA = 0.1;
-const DEFAULT_WARMUP_TOLERANCE = 8;
-const DEFAULT_MISS_TOLERANCE = 2;
+const DEFAULT_WARMUP_TOLERANCE = 2; // Instant detection
+const DEFAULT_MISS_TOLERANCE = 5;   // More grace when partially hidden
 
 export interface ControllerOptions {
     inputWidth: number;

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

@@ -33,20 +33,19 @@ class CropDetector {
   detectMoving(input) {
     const imageData = input;
 
-    // 🚀 MOONSHOT: Alternate between local crops and GLOBAL scan
-    // This solves the "not reading the whole screen" issue.
-    // Every 3 frames, we do a full screen downsampled scan.
-    if (this.lastRandomIndex % 3 === 0) {
+    // 🚀 MOONSHOT: High Frequency Global Scan
+    // Scan full screen every 2 frames when searching to guarantee instant recovery
+    if (this.lastRandomIndex % 2 === 0) {
       this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
       return this._detectGlobal(imageData);
     }
 
-    // Original moving crop logic for high-detail local detection
+    // Local crops (25 grid)
     const gridSize = 5;
     const idx = (this.lastRandomIndex - 1) % (gridSize * gridSize);
+    // ... rest of logic remains but we hit it less often because global scan is more successful
     const dx = idx % gridSize;
     const dy = Math.floor(idx / gridSize);
-
     const stepX = this.cropSize / 3;
     const stepY = this.cropSize / 3;
 
@@ -57,29 +56,26 @@ class CropDetector {
     startY = Math.max(0, Math.min(this.height - this.cropSize - 1, startY));
 
     this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
-
     return this._detect(imageData, startX, startY);
   }
 
-  /**
-   * Scans the ENTIRE frame by downsampling it to cropSize
-   */
   _detectGlobal(imageData) {
     const croppedData = new Float32Array(this.cropSize * this.cropSize);
     const scaleX = this.width / this.cropSize;
     const scaleY = this.height / this.cropSize;
 
-    // Fast downsample (nearest neighbor is enough for initial feature detection)
+    // Better sampling: avoid missing edges by jumping too much
     for (let y = 0; y < this.cropSize; y++) {
       const srcY = Math.floor(y * scaleY) * this.width;
       const dstY = y * this.cropSize;
       for (let x = 0; x < this.cropSize; x++) {
-        croppedData[dstY + x] = imageData[srcY + Math.floor(x * scaleX)];
+        // Average slightly to preserve gradients
+        const sx = Math.floor(x * scaleX);
+        croppedData[dstY + x] = (imageData[srcY + sx] + imageData[srcY + sx + 1]) * 0.5;
       }
     }
 
     const { featurePoints } = this.detector.detect(croppedData);
-
     featurePoints.forEach((p) => {
       p.x *= scaleX;
       p.y *= scaleY;

package/src/compiler/simple-ar.ts

@@ -163,7 +163,7 @@ class SimpleAR {
             this.lastMatrix = worldMatrix;
 
             if (!this.filters[targetIndex]) {
-                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 1.0, beta: 0.1 });
+                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 0.8, beta: 0.2 });
             }
 
             const flatMVT = [

package/src/compiler/tracker/tracker.js

@@ -214,29 +214,25 @@ class Tracker {
         continue;
       }
 
-      // Search in projected image
-      for (let sy = -searchOneSize; sy <= searchOneSize; sy += searchGap) {
+      // 🚀 MOONSHOT: Coarse-to-Fine Search for MAXIMUM FPS
+      // Step 1: Coarse search (Gap 4)
+      const coarseGap = 4;
+      for (let sy = -searchOneSize; sy <= searchOneSize; sy += coarseGap) {
         const cy = sCenterY + sy;
         if (cy < templateOneSize || cy >= markerHeight - templateOneSize) continue;
 
-        for (let sx = -searchOneSize; sx <= searchOneSize; sx += searchGap) {
+        for (let sx = -searchOneSize; sx <= searchOneSize; sx += coarseGap) {
           const cx = sCenterX + sx;
           if (cx < templateOneSize || cx >= markerWidth - templateOneSize) continue;
 
-          let sumI = 0;
-          let sumI2 = 0;
-          let sumIT = 0;
-
+          let sumI = 0, sumI2 = 0, sumIT = 0;
           for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
             const rowOffset = (cy + ty) * markerWidth;
             const tRowOffset = (ty + templateOneSize) * templateSize;
             for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
               const valI = projectedImage[rowOffset + (cx + tx)];
               const valT = templateData[tRowOffset + (tx + templateOneSize)];
-
-              sumI += valI;
-              sumI2 += valI * valI;
-              sumIT += valI * valT;
+              sumI += valI; sumI2 += valI * valI; sumIT += valI * valT;
             }
           }
 
@@ -252,6 +248,41 @@ class Tracker {
         }
       }
 
+      // Step 2: Fine refinement (Gap 1) only around the best coarse match
+      if (bestSim > AR2_SIM_THRESH) {
+        const fineCenterX = (bestX * scale) | 0;
+        const fineCenterY = (bestY * scale) | 0;
+        const fineSearch = coarseGap;
+
+        for (let sy = -fineSearch; sy <= fineSearch; sy++) {
+          const cy = fineCenterY + sy;
+          if (cy < templateOneSize || cy >= markerHeight - templateOneSize) continue;
+          for (let sx = -fineSearch; sx <= fineSearch; sx++) {
+            const cx = fineCenterX + sx;
+            if (cx < templateOneSize || cx >= markerWidth - templateOneSize) continue;
+
+            let sumI = 0, sumI2 = 0, sumIT = 0;
+            for (let ty = -templateOneSize; ty <= templateOneSize; ty++) {
+              const rowOffset = (cy + ty) * markerWidth;
+              const tRowOffset = (ty + templateOneSize) * templateSize;
+              for (let tx = -templateOneSize; tx <= templateOneSize; tx++) {
+                const valI = projectedImage[rowOffset + (cx + tx)];
+                const valT = templateData[tRowOffset + (tx + templateOneSize)];
+                sumI += valI; sumI2 += valI * valI; sumIT += valI * valT;
+              }
+            }
+            const varI = Math.sqrt(Math.max(0, sumI2 - (sumI * sumI) * oneOverNPixels));
+            if (varI < 0.0001) continue;
+            const sim = (sumIT - (sumI * sumT) * oneOverNPixels) / (varI * varT);
+            if (sim > bestSim) {
+              bestSim = sim;
+              bestX = cx / scale;
+              bestY = cy / scale;
+            }
+          }
+        }
+      }
+
       sims[f] = bestSim;
       matchingPoints.push([bestX, bestY]);
     }