@srsergio/taptapp-ar 1.0.71 → 1.0.73

package/dist/compiler/controller.js

@@ -18,8 +18,8 @@ const getControllerWorker = async () => {
     }
 };
 ControllerWorker = await getControllerWorker();
-const DEFAULT_FILTER_CUTOFF = 0.1;
-const DEFAULT_FILTER_BETA = 0.01;
+const DEFAULT_FILTER_CUTOFF = 1.0;
+const DEFAULT_FILTER_BETA = 0.1;
 const DEFAULT_WARMUP_TOLERANCE = 8;
 const DEFAULT_MISS_TOLERANCE = 2;
 class Controller {
@@ -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/matching/matching.js

@@ -3,11 +3,10 @@ import { compute as hammingCompute } from "./hamming-distance.js";
 import { computeHoughMatches } from "./hough.js";
 import { computeHomography } from "./ransacHomography.js";
 import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
-const INLIER_THRESHOLD = 10; // Relaxed from 3 to 10 for better robustness with LSH
-//const MIN_NUM_INLIERS = 8;  //default
-const MIN_NUM_INLIERS = 6;
-const CLUSTER_MAX_POP = 20; // Increased to explore more candidate clusters
-const HAMMING_THRESHOLD = 0.85; // Relaxed ratio test for binary descriptors
+const INLIER_THRESHOLD = 5.0; // Tightened from 10 to 5 for better precision
+const MIN_NUM_INLIERS = 8; // Restored to 8
+const CLUSTER_MAX_POP = 20;
+const HAMMING_THRESHOLD = 0.8; // Tightened from 0.85 to 0.8 for cleaner matches
 // match list of querpoints against pre-built list of keyframes
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {
     let debugExtra = {};

package/dist/compiler/offline-compiler.js

@@ -32,10 +32,10 @@ export class OfflineCompiler {
             const osModule = "os";
             const workerThreadsModule = "node:worker_threads";
             const [path, url, os, { Worker }] = await Promise.all([
-                import(pathModule),
-                import(urlModule),
-                import(osModule),
-                import(workerThreadsModule)
+                import(/* @vite-ignore */ pathModule),
+                import(/* @vite-ignore */ urlModule),
+                import(/* @vite-ignore */ osModule),
+                import(/* @vite-ignore */ workerThreadsModule)
             ]);
             const __filename = url.fileURLToPath(import.meta.url);
             const __dirname = path.dirname(__filename);
@@ -229,7 +229,7 @@ export class OfflineCompiler {
                         s: td.scale,
                         px,
                         py,
-                        d: this._pack4Bit(td.data),
+                        d: td.data,
                     };
                 }),
                 matchingData: item.matchingData.map((kf) => ({
@@ -313,11 +313,10 @@ export class OfflineCompiler {
                 }
                 td.px = px;
                 td.py = py;
-                // 🚀 MOONSHOT: Unpack 4-bit tracking data if detected
+                // No longer unpacking 4-bit, keeping original data
                 if (td.data && td.data.length === (td.width * td.height) / 2) {
                     td.data = this._unpack4Bit(td.data, td.width, td.height);
                 }
-                // Also handle 'd' property if it exists (msgpack mapping)
                 if (td.d && td.d.length === (td.w * td.h) / 2) {
                     td.d = this._unpack4Bit(td.d, td.w, td.h);
                 }

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: 0.1, beta: 0.01 });
+                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 1.0, beta: 0.1 });
             }
             const flatMVT = [
                 modelViewTransform[0][0], modelViewTransform[0][1], modelViewTransform[0][2], modelViewTransform[0][3],

package/dist/compiler/tracker/extract.js

@@ -9,7 +9,7 @@ const MAX_SIM_THRESH = 0.95;
 const MAX_THRESH = 0.9;
 const MIN_THRESH = 0.2;
 const SD_THRESH = 8.0;
-const OCCUPANCY_SIZE = 10; // Reducido de 16 para permitir puntos más cercanos
+const OCCUPANCY_SIZE = 8; // Reduced from 10 to allow more density
 // GPU mode flag - set to false to use original JS implementation
 let useGPU = true;
 /**
@@ -88,7 +88,7 @@ const extract = (image) => {
         }
     }
     // Determine dValue threshold for top 5% (aumentado de 2% para más candidatos)
-    const maxPoints = 0.05 * width * height;
+    const maxPoints = 0.10 * width * height; // Increased to 10% for more candidates
     let kThresh = 999;
     let filteredCount = 0;
     while (kThresh >= 0) {
@@ -289,16 +289,14 @@ const _getSimilarityOptimized = (options) => {
     // Full calculation - Optimized with 2x2 sub-sampling for SPEED
     let sxy = 0;
     const p1_start = (cy - templateSize) * width + (cx - templateSize);
-    for (let j = 0; j < templateWidth; j += 2) {
+    for (let j = 0; j < templateWidth; j++) {
         const rowOffset1 = p1_start + j * width;
         const rowOffset2 = j * templateWidth;
-        for (let i = 0; i < templateWidth; i += 2) {
+        for (let i = 0; i < templateWidth; i++) {
             sxy += imageData[rowOffset1 + i] * templateData[rowOffset2 + i];
         }
     }
-    // Factor to normalize sxy back to full template area
-    // templateWidth is 13, steps of 2 hit 7 points per dim = 49 total points (vs 169)
-    const sampledCount = Math.ceil(templateWidth / 2) ** 2;
+    const sampledCount = templateWidth * templateWidth;
     const totalCount = templateWidth * templateWidth;
     sxy *= (totalCount / sampledCount);
     // Covariance check

package/dist/compiler/tracker/tracker.d.ts

@@ -22,6 +22,7 @@ export class Tracker {
         }[];
         debugExtra: {};
     };
+    lastOctaveIndex: any[] | undefined;
     /**
      * Pure JS implementation of NCC matching
      */

package/dist/compiler/tracker/tracker.js

@@ -55,15 +55,22 @@ class Tracker {
         const p1 = computeScreenCoordiate(modelViewProjectionTransform, mW, 0);
         const screenW = Math.sqrt((p1.x - p0.x) ** 2 + (p1.y - p0.y) ** 2);
         // Select octave whose image width is closest to screenW
-        let octaveIndex = 0;
-        let minDiff = Infinity;
+        // Select the best octave based on current estimated distance/scale
+        // Hysteresis: prevent flip-flopping between octaves
+        if (!this.lastOctaveIndex)
+            this.lastOctaveIndex = [];
+        let octaveIndex = this.lastOctaveIndex[targetIndex] !== undefined ? this.lastOctaveIndex[targetIndex] : 0;
+        let minDiff = Math.abs(this.prebuiltData[targetIndex][octaveIndex].width - screenW);
+        // Threshold to switch: only switch if another octave is much better (20% improvement)
+        const switchThreshold = 0.8;
         for (let i = 0; i < this.prebuiltData[targetIndex].length; i++) {
             const diff = Math.abs(this.prebuiltData[targetIndex][i].width - screenW);
-            if (diff < minDiff) {
+            if (diff < minDiff * switchThreshold) {
                 minDiff = diff;
                 octaveIndex = i;
             }
         }
+        this.lastOctaveIndex[targetIndex] = octaveIndex;
         const prebuilt = this.prebuiltData[targetIndex][octaveIndex];
         // 1. Compute Projection (Warping)
         this._computeProjection(modelViewProjectionTransform, inputData, prebuilt);
@@ -87,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.71",
+    "version": "1.0.73",
     "description": "AR Compiler for Node.js and Browser",
     "repository": {
         "type": "git",

package/src/compiler/controller.ts

@@ -19,8 +19,8 @@ const getControllerWorker = async () => {
 };
 ControllerWorker = await getControllerWorker();
 
-const DEFAULT_FILTER_CUTOFF = 0.1;
-const DEFAULT_FILTER_BETA = 0.01;
+const DEFAULT_FILTER_CUTOFF = 1.0;
+const DEFAULT_FILTER_BETA = 0.1;
 const DEFAULT_WARMUP_TOLERANCE = 8;
 const DEFAULT_MISS_TOLERANCE = 2;
 
@@ -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/matching/matching.js

@@ -4,11 +4,10 @@ import { computeHoughMatches } from "./hough.js";
 import { computeHomography } from "./ransacHomography.js";
 import { multiplyPointHomographyInhomogenous, matrixInverse33 } from "../utils/geometry.js";
 
-const INLIER_THRESHOLD = 10; // Relaxed from 3 to 10 for better robustness with LSH
-//const MIN_NUM_INLIERS = 8;  //default
-const MIN_NUM_INLIERS = 6;
-const CLUSTER_MAX_POP = 20; // Increased to explore more candidate clusters
-const HAMMING_THRESHOLD = 0.85; // Relaxed ratio test for binary descriptors
+const INLIER_THRESHOLD = 5.0; // Tightened from 10 to 5 for better precision
+const MIN_NUM_INLIERS = 8;  // Restored to 8
+const CLUSTER_MAX_POP = 20;
+const HAMMING_THRESHOLD = 0.8; // Tightened from 0.85 to 0.8 for cleaner matches
 
 // match list of querpoints against pre-built list of keyframes
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {

package/src/compiler/offline-compiler.ts

@@ -39,10 +39,10 @@ export class OfflineCompiler {
             const workerThreadsModule = "node:worker_threads";
 
             const [path, url, os, { Worker }] = await Promise.all([
-                import(pathModule),
-                import(urlModule),
-                import(osModule),
-                import(workerThreadsModule)
+                import(/* @vite-ignore */ pathModule),
+                import(/* @vite-ignore */ urlModule),
+                import(/* @vite-ignore */ osModule),
+                import(/* @vite-ignore */ workerThreadsModule)
             ]);
 
             const __filename = url.fileURLToPath(import.meta.url);
@@ -274,7 +274,7 @@ export class OfflineCompiler {
                         px,
                         py,
 
-                        d: this._pack4Bit(td.data),
+                        d: td.data,
                     };
                 }),
                 matchingData: item.matchingData.map((kf: any) => ({
@@ -375,11 +375,10 @@ export class OfflineCompiler {
                 td.px = px;
                 td.py = py;
 
-                // 🚀 MOONSHOT: Unpack 4-bit tracking data if detected
+                // No longer unpacking 4-bit, keeping original data
                 if (td.data && td.data.length === (td.width * td.height) / 2) {
                     td.data = this._unpack4Bit(td.data, td.width, td.height);
                 }
-                // Also handle 'd' property if it exists (msgpack mapping)
                 if (td.d && td.d.length === (td.w * td.h) / 2) {
                     td.d = this._unpack4Bit(td.d, td.w, td.h);
                 }

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: 0.1, beta: 0.01 });
+                this.filters[targetIndex] = new OneEuroFilter({ minCutOff: 1.0, beta: 0.1 });
             }
 
             const flatMVT = [

package/src/compiler/tracker/extract.js

@@ -12,7 +12,7 @@ const MAX_SIM_THRESH = 0.95;
 const MAX_THRESH = 0.9;
 const MIN_THRESH = 0.2;
 const SD_THRESH = 8.0;
-const OCCUPANCY_SIZE = 10;  // Reducido de 16 para permitir puntos más cercanos
+const OCCUPANCY_SIZE = 8;  // Reduced from 10 to allow more density
 
 // GPU mode flag - set to false to use original JS implementation
 let useGPU = true;
@@ -102,7 +102,7 @@ const extract = (image) => {
   }
 
   // Determine dValue threshold for top 5% (aumentado de 2% para más candidatos)
-  const maxPoints = 0.05 * width * height;
+  const maxPoints = 0.10 * width * height; // Increased to 10% for more candidates
   let kThresh = 999;
   let filteredCount = 0;
   while (kThresh >= 0) {
@@ -344,17 +344,15 @@ const _getSimilarityOptimized = (options) => {
   let sxy = 0;
   const p1_start = (cy - templateSize) * width + (cx - templateSize);
 
-  for (let j = 0; j < templateWidth; j += 2) {
+  for (let j = 0; j < templateWidth; j++) {
     const rowOffset1 = p1_start + j * width;
     const rowOffset2 = j * templateWidth;
-    for (let i = 0; i < templateWidth; i += 2) {
+    for (let i = 0; i < templateWidth; i++) {
       sxy += imageData[rowOffset1 + i] * templateData[rowOffset2 + i];
     }
   }
 
-  // Factor to normalize sxy back to full template area
-  // templateWidth is 13, steps of 2 hit 7 points per dim = 49 total points (vs 169)
-  const sampledCount = Math.ceil(templateWidth / 2) ** 2;
+  const sampledCount = templateWidth * templateWidth;
   const totalCount = templateWidth * templateWidth;
   sxy *= (totalCount / sampledCount);
 

package/src/compiler/tracker/tracker.js

@@ -76,15 +76,24 @@ class Tracker {
     const screenW = Math.sqrt((p1.x - p0.x) ** 2 + (p1.y - p0.y) ** 2);
 
     // Select octave whose image width is closest to screenW
-    let octaveIndex = 0;
-    let minDiff = Infinity;
+    // Select the best octave based on current estimated distance/scale
+    // Hysteresis: prevent flip-flopping between octaves
+    if (!this.lastOctaveIndex) this.lastOctaveIndex = [];
+
+    let octaveIndex = this.lastOctaveIndex[targetIndex] !== undefined ? this.lastOctaveIndex[targetIndex] : 0;
+    let minDiff = Math.abs(this.prebuiltData[targetIndex][octaveIndex].width - screenW);
+
+    // Threshold to switch: only switch if another octave is much better (20% improvement)
+    const switchThreshold = 0.8;
+
     for (let i = 0; i < this.prebuiltData[targetIndex].length; i++) {
       const diff = Math.abs(this.prebuiltData[targetIndex][i].width - screenW);
-      if (diff < minDiff) {
+      if (diff < minDiff * switchThreshold) {
         minDiff = diff;
         octaveIndex = i;
       }
     }
+    this.lastOctaveIndex[targetIndex] = octaveIndex;
 
     const prebuilt = this.prebuiltData[targetIndex][octaveIndex];
 
@@ -127,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,