@srsergio/taptapp-ar 1.0.38 → 1.0.41

package/dist/compiler/controller.d.ts

@@ -65,16 +65,12 @@ export class Controller {
     dummyRun(input: any): void;
     getProjectionMatrix(): number[];
     getRotatedZ90Matrix(m: any): any[];
-    getWorldMatrix(modelViewTransform: any, targetIndex: any): any[] | null;
+    getWorldMatrix(modelViewTransform: any, targetIndex: any): any[];
     _detectAndMatch(inputData: any, targetIndexes: any): Promise<{
         targetIndex: any;
         modelViewTransform: any;
     }>;
-    _trackAndUpdate(inputData: any, lastModelViewTransform: any, targetIndex: any): Promise<{
-        modelViewTransform: any;
-        inliers: number;
-        octaveIndex: number;
-    } | null>;
+    _trackAndUpdate(inputData: any, lastModelViewTransform: any, targetIndex: any): Promise<any>;
     processVideo(input: any): void;
     stopProcessVideo(): void;
     detect(input: any): Promise<{
@@ -102,7 +98,6 @@ export class Controller {
             x: number;
             y: number;
         }[];
-        octaveIndex: number;
         debugExtra: {};
     }>;
     trackUpdate(modelViewTransform: any, trackFeatures: any): Promise<any>;
@@ -129,7 +124,7 @@ export class Controller {
     _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[] | null;
+    _glModelViewMatrix(modelViewTransform: any, targetIndex: any): any[];
     _glProjectionMatrix({ projectionTransform, width, height, near, far }: {
         projectionTransform: any;
         width: any;

package/dist/compiler/controller.js

@@ -181,18 +181,14 @@ class Controller {
         return { targetIndex: matchedTargetIndex, modelViewTransform };
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-        const result = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
-        if (result.worldCoords.length < 6)
+        const { worldCoords, screenCoords } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
+        if (worldCoords.length < 6)
             return null; // Umbral de puntos mínimos para mantener el seguimiento
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
-            worldCoords: result.worldCoords,
-            screenCoords: result.screenCoords,
+            worldCoords,
+            screenCoords,
         });
-        return {
-            modelViewTransform,
-            inliers: result.worldCoords.length,
-            octaveIndex: result.octaveIndex
-        };
+        return modelViewTransform;
     }
     processVideo(input) {
         if (this.processingVideo)
@@ -206,7 +202,6 @@ class Controller {
                 currentModelViewTransform: null,
                 trackCount: 0,
                 trackMiss: 0,
-                stabilityCount: 0, // Nuevo: Contador para Live Adaptation
                 filter: new OneEuroFilter({ minCutOff: this.filterMinCF, beta: this.filterBeta }),
             });
         }
@@ -219,22 +214,18 @@ class Controller {
                     return acc + (!!s.isTracking ? 1 : 0);
                 }, 0);
                 // detect and match only if less then maxTrack
-                // BUG FIX: Only match if we are NOT in a "ghosting" period for a target
-                // to prevent the "found but immediately lost" loop that keeps opacity at 1.
                 if (nTracking < this.maxTrack) {
                     const matchingIndexes = [];
                     for (let i = 0; i < this.trackingStates.length; i++) {
                         const trackingState = this.trackingStates[i];
                         if (trackingState.isTracking === true)
                             continue;
-                        if (trackingState.showing === true)
-                            continue; // Don't try to re-detect if we are still buffers-showing the last position
                         if (this.interestedTargetIndex !== -1 && this.interestedTargetIndex !== i)
                             continue;
                         matchingIndexes.push(i);
                     }
                     const { targetIndex: matchedTargetIndex, modelViewTransform } = await this._detectAndMatch(inputData, matchingIndexes);
-                    if (matchedTargetIndex !== -1 && modelViewTransform) {
+                    if (matchedTargetIndex !== -1) {
                         this.trackingStates[matchedTargetIndex].isTracking = true;
                         this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
                     }
@@ -243,29 +234,12 @@ class Controller {
                 for (let i = 0; i < this.trackingStates.length; i++) {
                     const trackingState = this.trackingStates[i];
                     if (trackingState.isTracking) {
-                        let result = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
-                        if (result === null) {
+                        let modelViewTransform = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
+                        if (modelViewTransform === null) {
                             trackingState.isTracking = false;
-                            trackingState.stabilityCount = 0;
                         }
                         else {
-                            trackingState.currentModelViewTransform = result.modelViewTransform;
-                            // --- LIVE MODEL ADAPTATION LOGIC ---
-                            // Si el tracking es muy sólido (muchos inliers) y estable, refinamos el modelo
-                            // Requisito: > 35 inliers (muy exigente) para evitar polución por ruido
-                            if (result.inliers > 35) {
-                                trackingState.stabilityCount++;
-                                if (trackingState.stabilityCount > 30) { // 30 frames (~1s) de estabilidad absoluta
-                                    this.tracker.applyLiveFeedback(i, result.octaveIndex, 0.05); // Menor alpha (5%) para ser más conservador
-                                    if (this.debugMode)
-                                        console.log(`✨ Live Reification: Target ${i} (Octave ${result.octaveIndex}) updated.`);
-                                    trackingState.stabilityCount = 0;
-                                }
-                            }
-                            else {
-                                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
-                            }
-                            // -----------------------------------
+                            trackingState.currentModelViewTransform = modelViewTransform;
                         }
                     }
                     // if not showing, then show it once it reaches warmup number of frames
@@ -297,7 +271,7 @@ class Controller {
                         }
                     }
                     // if showing, then call onUpdate, with world matrix
-                    if (trackingState.showing && trackingState.currentModelViewTransform) {
+                    if (trackingState.showing) {
                         const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
                         trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
                         let clone = [];
@@ -438,8 +412,6 @@ class Controller {
         return finalModelViewTransform;
     }
     _glModelViewMatrix(modelViewTransform, targetIndex) {
-        if (!modelViewTransform)
-            return null;
         const height = this.markerDimensions[targetIndex][1];
         const openGLWorldMatrix = [
             modelViewTransform[0][0],

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

@@ -20,7 +20,6 @@ export class Tracker {
             x: number;
             y: number;
         }[];
-        octaveIndex: number;
         debugExtra: {};
     };
     /**
@@ -34,11 +33,4 @@ export class Tracker {
      * Pure JS implementation of Bilinear Warping
      */
     _computeProjection(M: any, inputData: any, prebuilt: any): void;
-    /**
-     * Refines the target data (Living Mind Map) using actual camera feedback
-     * @param {number} targetIndex
-     * @param {number} octaveIndex
-     * @param {number} alpha - Blending factor (e.g. 0.1 for 10% new data)
-     */
-    applyLiveFeedback(targetIndex: number, octaveIndex: number, alpha: number): void;
 }

package/dist/compiler/tracker/tracker.js

@@ -87,7 +87,16 @@ class Tracker {
                 });
             }
         }
-        return { worldCoords, screenCoords, octaveIndex, debugExtra };
+        if (this.debugMode) {
+            debugExtra = {
+                octaveIndex,
+                projectedImage: Array.from(projectedImage),
+                matchingPoints,
+                goodTrack,
+                trackedPoints: screenCoords,
+            };
+        }
+        return { worldCoords, screenCoords, debugExtra };
     }
     /**
      * Pure JS implementation of NCC matching
@@ -223,33 +232,5 @@ class Tracker {
             }
         }
     }
-    /**
-     * Refines the target data (Living Mind Map) using actual camera feedback
-     * @param {number} targetIndex
-     * @param {number} octaveIndex
-     * @param {number} alpha - Blending factor (e.g. 0.1 for 10% new data)
-     */
-    applyLiveFeedback(targetIndex, octaveIndex, alpha) {
-        if (targetIndex === undefined || octaveIndex === undefined)
-            return;
-        const targetPrebuilts = this.prebuiltData[targetIndex];
-        if (!targetPrebuilts)
-            return;
-        const prebuilt = targetPrebuilts[octaveIndex];
-        if (!prebuilt || !prebuilt.projectedImage || !prebuilt.data)
-            return;
-        const markerPixels = prebuilt.data;
-        const projectedPixels = prebuilt.projectedImage;
-        const count = markerPixels.length;
-        // Blend the projected (camera-sourced) pixels into the marker reference data
-        // This allows the NCC matching to adapt to real-world lighting and print quality
-        for (let i = 0; i < count; i++) {
-            const val = projectedPixels[i];
-            if (isNaN(val))
-                continue; // Don't pollute with NaN
-            // Simple linear blend
-            markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * val;
-        }
-    }
 }
 export { Tracker };

package/package.json

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

package/src/compiler/controller.js

@@ -226,21 +226,17 @@ class Controller {
     return { targetIndex: matchedTargetIndex, modelViewTransform };
   }
   async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-    const result = this.tracker.track(
+    const { worldCoords, screenCoords } = this.tracker.track(
       inputData,
       lastModelViewTransform,
       targetIndex,
     );
-    if (result.worldCoords.length < 6) return null; // Umbral de puntos mínimos para mantener el seguimiento
+    if (worldCoords.length < 6) return null; // Umbral de puntos mínimos para mantener el seguimiento
     const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
-      worldCoords: result.worldCoords,
-      screenCoords: result.screenCoords,
+      worldCoords,
+      screenCoords,
     });
-    return {
-      modelViewTransform,
-      inliers: result.worldCoords.length,
-      octaveIndex: result.octaveIndex
-    };
+    return modelViewTransform;
   }
 
   processVideo(input) {
@@ -256,7 +252,6 @@ class Controller {
         currentModelViewTransform: null,
         trackCount: 0,
         trackMiss: 0,
-        stabilityCount: 0, // Nuevo: Contador para Live Adaptation
         filter: new OneEuroFilter({ minCutOff: this.filterMinCF, beta: this.filterBeta }),
       });
     }
@@ -272,14 +267,11 @@ class Controller {
         }, 0);
 
         // detect and match only if less then maxTrack
-        // BUG FIX: Only match if we are NOT in a "ghosting" period for a target
-        // to prevent the "found but immediately lost" loop that keeps opacity at 1.
         if (nTracking < this.maxTrack) {
           const matchingIndexes = [];
           for (let i = 0; i < this.trackingStates.length; i++) {
             const trackingState = this.trackingStates[i];
             if (trackingState.isTracking === true) continue;
-            if (trackingState.showing === true) continue; // Don't try to re-detect if we are still buffers-showing the last position
             if (this.interestedTargetIndex !== -1 && this.interestedTargetIndex !== i) continue;
 
             matchingIndexes.push(i);
@@ -288,7 +280,7 @@ class Controller {
           const { targetIndex: matchedTargetIndex, modelViewTransform } =
             await this._detectAndMatch(inputData, matchingIndexes);
 
-          if (matchedTargetIndex !== -1 && modelViewTransform) {
+          if (matchedTargetIndex !== -1) {
             this.trackingStates[matchedTargetIndex].isTracking = true;
             this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
           }
@@ -299,31 +291,15 @@ class Controller {
           const trackingState = this.trackingStates[i];
 
           if (trackingState.isTracking) {
-            let result = await this._trackAndUpdate(
+            let modelViewTransform = await this._trackAndUpdate(
               inputData,
               trackingState.currentModelViewTransform,
               i,
             );
-            if (result === null) {
+            if (modelViewTransform === null) {
               trackingState.isTracking = false;
-              trackingState.stabilityCount = 0;
             } else {
-              trackingState.currentModelViewTransform = result.modelViewTransform;
-
-              // --- LIVE MODEL ADAPTATION LOGIC ---
-              // Si el tracking es muy sólido (muchos inliers) y estable, refinamos el modelo
-              // Requisito: > 35 inliers (muy exigente) para evitar polución por ruido
-              if (result.inliers > 35) {
-                trackingState.stabilityCount++;
-                if (trackingState.stabilityCount > 30) { // 30 frames (~1s) de estabilidad absoluta
-                  this.tracker.applyLiveFeedback(i, result.octaveIndex, 0.05); // Menor alpha (5%) para ser más conservador
-                  if (this.debugMode) console.log(`✨ Live Reification: Target ${i} (Octave ${result.octaveIndex}) updated.`);
-                  trackingState.stabilityCount = 0;
-                }
-              } else {
-                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
-              }
-              // -----------------------------------
+              trackingState.currentModelViewTransform = modelViewTransform;
             }
           }
 
@@ -358,7 +334,7 @@ class Controller {
           }
 
           // if showing, then call onUpdate, with world matrix
-          if (trackingState.showing && trackingState.currentModelViewTransform) {
+          if (trackingState.showing) {
             const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
             trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
 
@@ -525,7 +501,6 @@ class Controller {
   }
 
   _glModelViewMatrix(modelViewTransform, targetIndex) {
-    if (!modelViewTransform) return null;
     const height = this.markerDimensions[targetIndex][1];
 
     const openGLWorldMatrix = [

package/src/compiler/tracker/tracker.js

@@ -127,7 +127,17 @@ class Tracker {
       }
     }
 
-    return { worldCoords, screenCoords, octaveIndex, debugExtra };
+    if (this.debugMode) {
+      debugExtra = {
+        octaveIndex,
+        projectedImage: Array.from(projectedImage),
+        matchingPoints,
+        goodTrack,
+        trackedPoints: screenCoords,
+      };
+    }
+
+    return { worldCoords, screenCoords, debugExtra };
   }
 
   /**
@@ -290,34 +300,6 @@ class Tracker {
       }
     }
   }
-
-  /**
-   * Refines the target data (Living Mind Map) using actual camera feedback
-   * @param {number} targetIndex 
-   * @param {number} octaveIndex 
-   * @param {number} alpha - Blending factor (e.g. 0.1 for 10% new data)
-   */
-  applyLiveFeedback(targetIndex, octaveIndex, alpha) {
-    if (targetIndex === undefined || octaveIndex === undefined) return;
-    const targetPrebuilts = this.prebuiltData[targetIndex];
-    if (!targetPrebuilts) return;
-
-    const prebuilt = targetPrebuilts[octaveIndex];
-    if (!prebuilt || !prebuilt.projectedImage || !prebuilt.data) return;
-
-    const markerPixels = prebuilt.data;
-    const projectedPixels = prebuilt.projectedImage;
-    const count = markerPixels.length;
-
-    // Blend the projected (camera-sourced) pixels into the marker reference data
-    // This allows the NCC matching to adapt to real-world lighting and print quality
-    for (let i = 0; i < count; i++) {
-      const val = projectedPixels[i];
-      if (isNaN(val)) continue; // Don't pollute with NaN
-      // Simple linear blend
-      markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * val;
-    }
-  }
 }
 
 export { Tracker };