@srsergio/taptapp-ar 1.0.37 → 1.0.40

package/dist/compiler/controller.d.ts

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

package/dist/compiler/controller.js

@@ -181,17 +181,19 @@ class Controller {
         return { targetIndex: matchedTargetIndex, modelViewTransform };
     }
     async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-        const { worldCoords, screenCoords, debugExtra } = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
-        if (worldCoords.length < 6)
+        if (!lastModelViewTransform)
+            return null;
+        const result = this.tracker.track(inputData, lastModelViewTransform, targetIndex);
+        if (result.worldCoords.length < 6)
             return null; // Umbral de puntos mínimos para mantener el seguimiento
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
-            worldCoords,
-            screenCoords,
+            worldCoords: result.worldCoords,
+            screenCoords: result.screenCoords,
         });
         return {
             modelViewTransform,
-            inliers: worldCoords.length,
-            octaveIndex: debugExtra.octaveIndex
+            inliers: result.worldCoords.length,
+            octaveIndex: result.octaveIndex
         };
     }
     processVideo(input) {
@@ -219,18 +221,22 @@ 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) {
+                    if (matchedTargetIndex !== -1 && modelViewTransform) {
                         this.trackingStates[matchedTargetIndex].isTracking = true;
                         this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
                     }
@@ -239,72 +245,79 @@ 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) {
+                        if (!trackingState.currentModelViewTransform) {
                             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
-                            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
-                                }
+                            let result = await this._trackAndUpdate(inputData, trackingState.currentModelViewTransform, i);
+                            if (result === null) {
+                                trackingState.isTracking = false;
+                                trackingState.stabilityCount = 0;
                             }
                             else {
-                                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
+                                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);
+                                }
+                                // -----------------------------------
                             }
-                            // -----------------------------------
                         }
-                    }
-                    // if not showing, then show it once it reaches warmup number of frames
-                    if (!trackingState.showing) {
-                        if (trackingState.isTracking) {
-                            trackingState.trackMiss = 0;
-                            trackingState.trackCount += 1;
-                            if (trackingState.trackCount > this.warmupTolerance) {
-                                trackingState.showing = true;
-                                trackingState.trackingMatrix = null;
-                                trackingState.filter.reset();
+                        // if not showing, then show it once it reaches warmup number of frames
+                        if (!trackingState.showing) {
+                            if (trackingState.isTracking) {
+                                trackingState.trackMiss = 0;
+                                trackingState.trackCount += 1;
+                                if (trackingState.trackCount > this.warmupTolerance) {
+                                    trackingState.showing = true;
+                                    trackingState.trackingMatrix = null;
+                                    trackingState.filter.reset();
+                                }
                             }
                         }
-                    }
-                    // if showing, then count miss, and hide it when reaches tolerance
-                    if (trackingState.showing) {
-                        if (!trackingState.isTracking) {
-                            trackingState.trackCount = 0;
-                            trackingState.trackMiss += 1;
-                            if (trackingState.trackMiss > this.missTolerance) {
-                                trackingState.showing = false;
-                                trackingState.trackingMatrix = null;
-                                this.onUpdate &&
-                                    this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
+                        // if showing, then count miss, and hide it when reaches tolerance
+                        if (trackingState.showing) {
+                            if (!trackingState.isTracking) {
+                                trackingState.trackCount = 0;
+                                trackingState.trackMiss += 1;
+                                if (trackingState.trackMiss > this.missTolerance) {
+                                    trackingState.showing = false;
+                                    trackingState.trackingMatrix = null;
+                                    this.onUpdate &&
+                                        this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
+                                }
+                            }
+                            else {
+                                trackingState.trackMiss = 0;
                             }
                         }
-                        else {
-                            trackingState.trackMiss = 0;
-                        }
-                    }
-                    // if showing, then call onUpdate, with world matrix
-                    if (trackingState.showing) {
-                        const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
-                        trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
-                        let clone = [];
-                        for (let j = 0; j < trackingState.trackingMatrix.length; j++) {
-                            clone[j] = trackingState.trackingMatrix[j];
-                        }
-                        const isInputRotated = input.width === this.inputHeight && input.height === this.inputWidth;
-                        if (isInputRotated) {
-                            clone = this.getRotatedZ90Matrix(clone);
+                        // if showing, then call onUpdate, with world matrix
+                        if (trackingState.showing && trackingState.currentModelViewTransform) {
+                            const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
+                            trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
+                            let clone = [];
+                            for (let j = 0; j < trackingState.trackingMatrix.length; j++) {
+                                clone[j] = trackingState.trackingMatrix[j];
+                            }
+                            const isInputRotated = input.width === this.inputHeight && input.height === this.inputWidth;
+                            if (isInputRotated) {
+                                clone = this.getRotatedZ90Matrix(clone);
+                            }
+                            this.onUpdate &&
+                                this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: clone, modelViewTransform: trackingState.currentModelViewTransform });
                         }
-                        this.onUpdate &&
-                            this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: clone, modelViewTransform: trackingState.currentModelViewTransform });
                     }
                 }
                 this.onUpdate && this.onUpdate({ type: "processDone" });
@@ -433,6 +446,8 @@ 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,6 +20,7 @@ export class Tracker {
             x: number;
             y: number;
         }[];
+        octaveIndex: number;
         debugExtra: {};
     };
     /**

package/dist/compiler/tracker/tracker.js

@@ -46,6 +46,8 @@ class Tracker {
     }
     track(inputData, lastModelViewTransform, targetIndex) {
         let debugExtra = {};
+        if (!lastModelViewTransform)
+            return { worldCoords: [], screenCoords: [], octaveIndex: 0, debugExtra };
         // Select the best octave based on current estimated distance/scale
         // We want the octave where the marker size is closest to its projected size on screen
         const modelViewProjectionTransform = buildModelViewProjectionTransform(this.projectionTransform, lastModelViewTransform);
@@ -87,16 +89,7 @@ class Tracker {
                 });
             }
         }
-        if (this.debugMode) {
-            debugExtra = {
-                octaveIndex,
-                projectedImage: Array.from(projectedImage),
-                matchingPoints,
-                goodTrack,
-                trackedPoints: screenCoords,
-            };
-        }
-        return { worldCoords, screenCoords, debugExtra };
+        return { worldCoords, screenCoords, octaveIndex, debugExtra };
     }
     /**
      * Pure JS implementation of NCC matching
@@ -239,8 +232,13 @@ class Tracker {
      * @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)
+        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;
@@ -248,8 +246,11 @@ class Tracker {
         // 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 * projectedPixels[i];
+            markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * val;
         }
     }
 }

package/package.json

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

package/src/compiler/controller.js

@@ -226,20 +226,21 @@ class Controller {
     return { targetIndex: matchedTargetIndex, modelViewTransform };
   }
   async _trackAndUpdate(inputData, lastModelViewTransform, targetIndex) {
-    const { worldCoords, screenCoords, debugExtra } = this.tracker.track(
+    if (!lastModelViewTransform) return null;
+    const result = this.tracker.track(
       inputData,
       lastModelViewTransform,
       targetIndex,
     );
-    if (worldCoords.length < 6) return null; // Umbral de puntos mínimos para mantener el seguimiento
+    if (result.worldCoords.length < 6) return null; // Umbral de puntos mínimos para mantener el seguimiento
     const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
-      worldCoords,
-      screenCoords,
+      worldCoords: result.worldCoords,
+      screenCoords: result.screenCoords,
     });
     return {
       modelViewTransform,
-      inliers: worldCoords.length,
-      octaveIndex: debugExtra.octaveIndex
+      inliers: result.worldCoords.length,
+      octaveIndex: result.octaveIndex
     };
   }
 
@@ -272,11 +273,14 @@ 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);
@@ -285,7 +289,7 @@ class Controller {
           const { targetIndex: matchedTargetIndex, modelViewTransform } =
             await this._detectAndMatch(inputData, matchingIndexes);
 
-          if (matchedTargetIndex !== -1) {
+          if (matchedTargetIndex !== -1 && modelViewTransform) {
             this.trackingStates[matchedTargetIndex].isTracking = true;
             this.trackingStates[matchedTargetIndex].currentModelViewTransform = modelViewTransform;
           }
@@ -296,84 +300,89 @@ class Controller {
           const trackingState = this.trackingStates[i];
 
           if (trackingState.isTracking) {
-            let result = await this._trackAndUpdate(
-              inputData,
-              trackingState.currentModelViewTransform,
-              i,
-            );
-            if (result === null) {
+            if (!trackingState.currentModelViewTransform) {
               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
-              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
-                }
+              let result = await this._trackAndUpdate(
+                inputData,
+                trackingState.currentModelViewTransform,
+                i,
+              );
+              if (result === null) {
+                trackingState.isTracking = false;
+                trackingState.stabilityCount = 0;
               } else {
-                trackingState.stabilityCount = Math.max(0, trackingState.stabilityCount - 1);
+                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);
+                }
+                // -----------------------------------
               }
-              // -----------------------------------
             }
-          }
 
-          // if not showing, then show it once it reaches warmup number of frames
-          if (!trackingState.showing) {
-            if (trackingState.isTracking) {
-              trackingState.trackMiss = 0;
-              trackingState.trackCount += 1;
-              if (trackingState.trackCount > this.warmupTolerance) {
-                trackingState.showing = true;
-                trackingState.trackingMatrix = null;
-                trackingState.filter.reset();
+            // if not showing, then show it once it reaches warmup number of frames
+            if (!trackingState.showing) {
+              if (trackingState.isTracking) {
+                trackingState.trackMiss = 0;
+                trackingState.trackCount += 1;
+                if (trackingState.trackCount > this.warmupTolerance) {
+                  trackingState.showing = true;
+                  trackingState.trackingMatrix = null;
+                  trackingState.filter.reset();
+                }
               }
             }
-          }
 
-          // if showing, then count miss, and hide it when reaches tolerance
-          if (trackingState.showing) {
-            if (!trackingState.isTracking) {
-              trackingState.trackCount = 0;
-              trackingState.trackMiss += 1;
-
-              if (trackingState.trackMiss > this.missTolerance) {
-                trackingState.showing = false;
-                trackingState.trackingMatrix = null;
-                this.onUpdate &&
-                  this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
+            // if showing, then count miss, and hide it when reaches tolerance
+            if (trackingState.showing) {
+              if (!trackingState.isTracking) {
+                trackingState.trackCount = 0;
+                trackingState.trackMiss += 1;
+
+                if (trackingState.trackMiss > this.missTolerance) {
+                  trackingState.showing = false;
+                  trackingState.trackingMatrix = null;
+                  this.onUpdate &&
+                    this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: null });
+                }
+              } else {
+                trackingState.trackMiss = 0;
               }
-            } else {
-              trackingState.trackMiss = 0;
             }
-          }
 
-          // if showing, then call onUpdate, with world matrix
-          if (trackingState.showing) {
-            const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
-            trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
+            // if showing, then call onUpdate, with world matrix
+            if (trackingState.showing && trackingState.currentModelViewTransform) {
+              const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
+              trackingState.trackingMatrix = trackingState.filter.filter(Date.now(), worldMatrix);
 
-            let clone = [];
-            for (let j = 0; j < trackingState.trackingMatrix.length; j++) {
-              clone[j] = trackingState.trackingMatrix[j];
-            }
+              let clone = [];
+              for (let j = 0; j < trackingState.trackingMatrix.length; j++) {
+                clone[j] = trackingState.trackingMatrix[j];
+              }
 
-            const isInputRotated =
-              input.width === this.inputHeight && input.height === this.inputWidth;
-            if (isInputRotated) {
-              clone = this.getRotatedZ90Matrix(clone);
-            }
+              const isInputRotated =
+                input.width === this.inputHeight && input.height === this.inputWidth;
+              if (isInputRotated) {
+                clone = this.getRotatedZ90Matrix(clone);
+              }
 
-            this.onUpdate &&
-              this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: clone, modelViewTransform: trackingState.currentModelViewTransform });
+              this.onUpdate &&
+                this.onUpdate({ type: "updateMatrix", targetIndex: i, worldMatrix: clone, modelViewTransform: trackingState.currentModelViewTransform });
+            }
           }
         }
-
         this.onUpdate && this.onUpdate({ type: "processDone" });
 
         // Use requestAnimationFrame if available, otherwise just wait briefly
@@ -521,6 +530,7 @@ class Controller {
   }
 
   _glModelViewMatrix(modelViewTransform, targetIndex) {
+    if (!modelViewTransform) return null;
     const height = this.markerDimensions[targetIndex][1];
 
     const openGLWorldMatrix = [

package/src/compiler/tracker/tracker.js

@@ -61,6 +61,7 @@ class Tracker {
 
   track(inputData, lastModelViewTransform, targetIndex) {
     let debugExtra = {};
+    if (!lastModelViewTransform) return { worldCoords: [], screenCoords: [], octaveIndex: 0, debugExtra };
 
     // Select the best octave based on current estimated distance/scale
     // We want the octave where the marker size is closest to its projected size on screen
@@ -127,17 +128,7 @@ class Tracker {
       }
     }
 
-    if (this.debugMode) {
-      debugExtra = {
-        octaveIndex,
-        projectedImage: Array.from(projectedImage),
-        matchingPoints,
-        goodTrack,
-        trackedPoints: screenCoords,
-      };
-    }
-
-    return { worldCoords, screenCoords, debugExtra };
+    return { worldCoords, screenCoords, octaveIndex, debugExtra };
   }
 
   /**
@@ -308,8 +299,12 @@ class Tracker {
    * @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;
+    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;
@@ -318,8 +313,10 @@ class Tracker {
     // 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 * projectedPixels[i];
+      markerPixels[i] = (1 - alpha) * markerPixels[i] + alpha * val;
     }
   }
 }