@srsergio/taptapp-ar 1.0.36 → 1.0.37

package/dist/compiler/controller.d.ts

@@ -70,7 +70,11 @@ export class Controller {
         targetIndex: any;
         modelViewTransform: any;
     }>;
-    _trackAndUpdate(inputData: any, lastModelViewTransform: any, targetIndex: any): Promise<any>;
+    _trackAndUpdate(inputData: any, lastModelViewTransform: any, targetIndex: any): Promise<{
+        modelViewTransform: any;
+        inliers: number;
+        octaveIndex: any;
+    } | null>;
     processVideo(input: any): void;
     stopProcessVideo(): void;
     detect(input: any): Promise<{

package/dist/compiler/controller.js

@@ -181,14 +181,18 @@ class Controller {
         return { targetIndex: matchedTargetIndex, modelViewTransform };
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-        const { worldCoords, screenCoords } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
+        const { worldCoords, screenCoords, debugExtra } = 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,
             screenCoords,
         });
-        return modelViewTransform;
+        return {
+            modelViewTransform,
+            inliers: worldCoords.length,
+            octaveIndex: debugExtra.octaveIndex
+        };
     }
     processVideo(input) {
         if (this.processingVideo)
@@ -202,6 +206,7 @@ class Controller {
                 currentModelViewTransform: null,
                 trackCount: 0,
                 trackMiss: 0,
+                stabilityCount: 0, // Nuevo: Contador para Live Adaptation
                 filter: new OneEuroFilter({ minCutOff: this.filterMinCF, beta: this.filterBeta }),
             });
         }
@@ -234,12 +239,28 @@ class Controller {
                 for (let i = 0; i < this.trackingStates.length; i++) {
                     const trackingState = this.trackingStates[i];
                     if (trackingState.isTracking) {
-                        let modelViewTransform = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
-                        if (modelViewTransform === null) {
+                        let result = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
+                        if (result === null) {
                             trackingState.isTracking = false;
+                            trackingState.stabilityCount = 0;
                         }
                         else {
-                            trackingState.currentModelViewTransform = modelViewTransform;
+                            trackingState.currentModelViewTransform = result.modelViewTransform;
+                            // --- LIVE MODEL ADAPTATION LOGIC ---
+                            // Si el tracking es muy sólido (muchos inliers) y estable, refinamos el modelo
+                            if (result.inliers > 25) {
+                                trackingState.stabilityCount++;
+                                if (trackingState.stabilityCount > 20) { // 20 frames de estabilidad absoluta
+                                    this.tracker.applyLiveFeedback(i, result.octaveIndex, 0.1); // 10% de mezcla real
+                                    if (this.debugMode)
+                                        console.log(`✨ Live Reification: Target ${i} (Octave ${result.octaveIndex}) updated with real-world textures.`);
+                                    trackingState.stabilityCount = 0; // Reset para la siguiente actualización
+                                }
+                            }
+                            else {
+                                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
+                            }
+                            // -----------------------------------
                         }
                     }
                     // if not showing, then show it once it reaches warmup number of frames

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

@@ -33,4 +33,11 @@ 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

@@ -232,5 +232,25 @@ 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) {
+        const prebuilt = this.prebuiltData[targetIndex][octaveIndex];
+        if (!prebuilt || !prebuilt.projectedImage)
+            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++) {
+            // Simple linear blend
+            markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * projectedPixels[i];
+        }
+    }
 }
 export { Tracker };

package/package.json

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

package/src/compiler/controller.js

@@ -226,7 +226,7 @@ class Controller {
     return { targetIndex: matchedTargetIndex, modelViewTransform };
   }
   async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-    const { worldCoords, screenCoords } = this.tracker.track(
+    const { worldCoords, screenCoords, debugExtra } = this.tracker.track(
       inputData,
       lastModelViewTransform,
       targetIndex,
@@ -236,7 +236,11 @@ class Controller {
       worldCoords,
       screenCoords,
     });
-    return modelViewTransform;
+    return {
+      modelViewTransform,
+      inliers: worldCoords.length,
+      octaveIndex: debugExtra.octaveIndex
+    };
   }
 
   processVideo(input) {
@@ -252,6 +256,7 @@ class Controller {
         currentModelViewTransform: null,
         trackCount: 0,
         trackMiss: 0,
+        stabilityCount: 0, // Nuevo: Contador para Live Adaptation
         filter: new OneEuroFilter({ minCutOff: this.filterMinCF, beta: this.filterBeta }),
       });
     }
@@ -291,15 +296,30 @@ class Controller {
           const trackingState = this.trackingStates[i];
 
           if (trackingState.isTracking) {
-            let modelViewTransform = await this._trackAndUpdate(
+            let result = await this._trackAndUpdate(
               inputData,
               trackingState.currentModelViewTransform,
               i,
             );
-            if (modelViewTransform === null) {
+            if (result === null) {
               trackingState.isTracking = false;
+              trackingState.stabilityCount = 0;
             } else {
-              trackingState.currentModelViewTransform = modelViewTransform;
+              trackingState.currentModelViewTransform = result.modelViewTransform;
+
+              // --- LIVE MODEL ADAPTATION LOGIC ---
+              // Si el tracking es muy sólido (muchos inliers) y estable, refinamos el modelo
+              if (result.inliers > 25) {
+                trackingState.stabilityCount++;
+                if (trackingState.stabilityCount > 20) { // 20 frames de estabilidad absoluta
+                  this.tracker.applyLiveFeedback(i, result.octaveIndex, 0.1); // 10% de mezcla real
+                  if (this.debugMode) console.log(`✨ Live Reification: Target ${i} (Octave ${result.octaveIndex}) updated with real-world textures.`);
+                  trackingState.stabilityCount = 0; // Reset para la siguiente actualización
+                }
+              } else {
+                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
+              }
+              // -----------------------------------
             }
           }
 

package/src/compiler/tracker/tracker.js

@@ -300,6 +300,28 @@ 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) {
+    const prebuilt = this.prebuiltData[targetIndex][octaveIndex];
+    if (!prebuilt || !prebuilt.projectedImage) 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++) {
+      // Simple linear blend
+      markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * projectedPixels[i];
+    }
+  }
 }
 
 export { Tracker };