@srsergio/taptapp-ar 1.0.72 → 1.0.74

package/dist/compiler/controller.js

@@ -173,8 +173,8 @@ class Controller {
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
         const { worldCoords, screenCoords } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
-        if (worldCoords.length < 6)
-            return null;
+        if (worldCoords.length < 10)
+            return null; // Increased from 6 to 10 for better noise rejection
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
             worldCoords,
             screenCoords,

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

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

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

@@ -24,27 +24,51 @@ class CropDetector {
     }
     detectMoving(input) {
         const imageData = input;
-        // Expanded to 5x5 grid (25 positions) for better coverage
+        // 🚀 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) {
+            this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
+            return this._detectGlobal(imageData);
+        }
+        // Original moving crop logic for high-detail local detection
         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 idx = (this.lastRandomIndex - 1) % (gridSize * gridSize);
+        const dx = idx % gridSize;
+        const dy = Math.floor(idx / gridSize);
         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) % (gridSize * gridSize);
-        const result = this._detect(imageData, startX, startY);
-        return result;
+        startX = Math.max(0, Math.min(this.width - this.cropSize - 1, startX));
+        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)
+        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)];
+            }
+        }
+        const { featurePoints } = this.detector.detect(croppedData);
+        featurePoints.forEach((p) => {
+            p.x *= scaleX;
+            p.y *= scaleY;
+        });
+        return {
+            featurePoints,
+            debugExtra: this.debugMode ? { projectedImage: Array.from(croppedData), isGlobal: true } : {}
+        };
     }
     _detect(imageData, startX, startY) {
         // Crop manually since imageData is now a flat array (width * height)

package/dist/compiler/tracker/tracker.js

@@ -1,7 +1,7 @@
 import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
 const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
-const AR2_SEARCH_SIZE = 18;
+const AR2_SEARCH_SIZE = 34; // Increased from 18 to 34 for much better fast-motion tracking
 const AR2_SEARCH_GAP = 1;
 const AR2_SIM_THRESH = 0.6;
 const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
@@ -94,6 +94,25 @@ class Tracker {
                 });
             }
         }
+        // 2.1 Spatial distribution check: Avoid getting stuck in corners/noise
+        if (screenCoords.length >= 10) {
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+            for (const p of screenCoords) {
+                if (p.x < minX)
+                    minX = p.x;
+                if (p.y < minY)
+                    minY = p.y;
+                if (p.x > maxX)
+                    maxX = p.x;
+                if (p.y > maxY)
+                    maxY = p.y;
+            }
+            const detectedDiagonal = Math.sqrt((maxX - minX) ** 2 + (maxY - minY) ** 2);
+            // If the points cover too little space compared to the screen size of the marker, it's a glitch
+            if (detectedDiagonal < screenW * 0.15) {
+                return { worldCoords: [], screenCoords: [], debugExtra };
+            }
+        }
         if (this.debugMode) {
             debugExtra = {
                 octaveIndex,

package/package.json

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

package/src/compiler/controller.ts

@@ -233,7 +233,7 @@ class Controller {
             lastModelViewTransform,
             targetIndex,
         );
-        if (worldCoords.length < 6) return null;
+        if (worldCoords.length < 10) return null; // Increased from 6 to 10 for better noise rejection
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
             worldCoords,
             screenCoords,

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

@@ -33,28 +33,62 @@ class CropDetector {
   detectMoving(input) {
     const imageData = input;
 
-    // Expanded to 5x5 grid (25 positions) for better coverage
+    // 🚀 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) {
+      this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
+      return this._detectGlobal(imageData);
+    }
+
+    // Original moving crop logic for high-detail local detection
     const gridSize = 5;
-    const dx = this.lastRandomIndex % gridSize;
-    const dy = Math.floor(this.lastRandomIndex / gridSize);
+    const idx = (this.lastRandomIndex - 1) % (gridSize * gridSize);
+    const dx = idx % gridSize;
+    const dy = Math.floor(idx / 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) 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;
+    startX = Math.max(0, Math.min(this.width - this.cropSize - 1, startX));
+    startY = Math.max(0, Math.min(this.height - this.cropSize - 1, startY));
 
-    this.lastRandomIndex = (this.lastRandomIndex + 1) % (gridSize * gridSize);
+    this.lastRandomIndex = (this.lastRandomIndex + 1) % 25;
 
-    const result = this._detect(imageData, startX, startY);
-    return result;
+    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)
+    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)];
+      }
+    }
+
+    const { featurePoints } = this.detector.detect(croppedData);
+
+    featurePoints.forEach((p) => {
+      p.x *= scaleX;
+      p.y *= scaleY;
+    });
+
+    return {
+      featurePoints,
+      debugExtra: this.debugMode ? { projectedImage: Array.from(croppedData), isGlobal: true } : {}
+    };
   }
 
   _detect(imageData, startX, startY) {

package/src/compiler/tracker/tracker.js

@@ -2,7 +2,7 @@ import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../es
 
 const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
-const AR2_SEARCH_SIZE = 18;
+const AR2_SEARCH_SIZE = 34; // Increased from 18 to 34 for much better fast-motion tracking
 const AR2_SEARCH_GAP = 1;
 const AR2_SIM_THRESH = 0.6;
 
@@ -136,6 +136,20 @@ class Tracker {
       }
     }
 
+    // 2.1 Spatial distribution check: Avoid getting stuck in corners/noise
+    if (screenCoords.length >= 10) {
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const p of screenCoords) {
+        if (p.x < minX) minX = p.x; if (p.y < minY) minY = p.y;
+        if (p.x > maxX) maxX = p.x; if (p.y > maxY) maxY = p.y;
+      }
+      const detectedDiagonal = Math.sqrt((maxX - minX) ** 2 + (maxY - minY) ** 2);
+
+      // If the points cover too little space compared to the screen size of the marker, it's a glitch
+      if (detectedDiagonal < screenW * 0.15) {
+        return { worldCoords: [], screenCoords: [], debugExtra };
+      }
+    }
     if (this.debugMode) {
       debugExtra = {
         octaveIndex,