@srsergio/taptapp-ar 1.0.79 → 1.0.80

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

@@ -11,6 +11,13 @@ export class Tracker {
     templateBuffer: Float32Array<ArrayBuffer>;
     dummyRun(inputData: any): void;
     track(inputData: any, lastModelViewTransform: any, targetIndex: any): {
+        worldCoords: never[];
+        screenCoords: never[];
+        reliabilities: never[];
+        debugExtra: {};
+        indices?: undefined;
+        octaveIndex?: undefined;
+    } | {
         worldCoords: {
             x: number;
             y: number;
@@ -20,6 +27,9 @@ export class Tracker {
             x: number;
             y: number;
         }[];
+        reliabilities: number[];
+        indices: number[];
+        octaveIndex: any;
         debugExtra: {};
     };
     lastOctaveIndex: any[] | undefined;

package/dist/compiler/tracker/tracker.js

@@ -1,9 +1,9 @@
 import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
 const AR2_DEFAULT_TS = 6;
 const AR2_DEFAULT_TS_GAP = 1;
-const AR2_SEARCH_SIZE = 34; // Increased from 18 to 34 for much better fast-motion tracking
+const AR2_SEARCH_SIZE = 25; // Reduced from 34 to 25 to prevent background latching
 const AR2_SEARCH_GAP = 1;
-const AR2_SIM_THRESH = 0.6;
+const AR2_SIM_THRESH = 0.65; // Increased from 0.6 to reduce false positives
 const TRACKING_KEYFRAME = 0; // 0: 128px (optimized)
 class Tracker {
     constructor(markerDimensions, trackingDataList, projectionTransform, inputWidth, inputHeight, debugMode = false) {
@@ -82,6 +82,7 @@ class Tracker {
         const screenCoords = [];
         const goodTrack = [];
         const { px, py, s: scale } = trackingFrame;
+        const reliabilities = [];
         for (let i = 0; i < matchingPoints.length; i++) {
             if (sim[i] > AR2_SIM_THRESH && i < px.length) {
                 goodTrack.push(i);
@@ -92,6 +93,7 @@ class Tracker {
                     y: py[i] / scale,
                     z: 0,
                 });
+                reliabilities.push(sim[i]);
             }
         }
         // 2.1 Spatial distribution check: Avoid getting stuck in corners/noise
@@ -110,7 +112,7 @@ class Tracker {
             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 };
+                return { worldCoords: [], screenCoords: [], reliabilities: [], debugExtra };
             }
         }
         if (this.debugMode) {
@@ -122,7 +124,7 @@ class Tracker {
                 trackedPoints: screenCoords,
             };
         }
-        return { worldCoords, screenCoords, debugExtra };
+        return { worldCoords, screenCoords, reliabilities, indices: goodTrack, octaveIndex, debugExtra };
     }
     /**
      * Pure JS implementation of NCC matching

package/dist/react/TaptappAR.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { useAR } from "./use-ar.js";
 export const TaptappAR = ({ config, className = "", showScanningOverlay = true, showErrorOverlay = true }) => {
-    const { containerRef, overlayRef, status, toggleVideo } = useAR(config);
+    const { containerRef, overlayRef, status, toggleVideo, trackedPoints } = useAR(config);
     // Simple heuristic to determine if it's a video or image
     // based on the presence of videoSrc and common extensions
     const isVideo = useMemo(() => {
@@ -12,7 +12,13 @@ export const TaptappAR = ({ config, className = "", showScanningOverlay = true,
         const url = config.videoSrc.toLowerCase().split('?')[0];
         return videoExtensions.some(ext => url.endsWith(ext)) || config.videoSrc.includes('video');
     }, [config.videoSrc]);
-    return (_jsxs("div", { className: `taptapp-ar-wrapper ${className} ${status}`, style: { position: 'relative', width: '100%', height: '100%', overflow: 'hidden' }, children: [showScanningOverlay && status === "scanning" && (_jsx("div", { className: "taptapp-ar-overlay taptapp-ar-scanning", children: _jsxs("div", { className: "scanning-content", children: [_jsxs("div", { className: "scanning-frame", children: [_jsx("img", { className: "target-preview", src: config.targetImageSrc, alt: "Target", crossOrigin: "anonymous" }), _jsx("div", { className: "scanning-line" })] }), _jsx("p", { className: "scanning-text", children: "Apunta a la imagen para comenzar" })] }) })), showErrorOverlay && status === "error" && (_jsx("div", { className: "taptapp-ar-overlay taptapp-ar-error", children: _jsxs("div", { className: "error-content", children: [_jsx("span", { className: "error-icon", children: "\u26A0\uFE0F" }), _jsx("p", { className: "error-title", children: "No se pudo iniciar AR" }), _jsx("p", { className: "error-text", children: "Verifica los permisos de c\u00E1mara" }), _jsx("button", { className: "retry-btn", onClick: () => window.location.reload(), children: "Reintentar" })] }) })), _jsx("div", { ref: containerRef, className: "taptapp-ar-container", onClick: toggleVideo, style: { width: '100%', height: '100%' }, children: isVideo ? (_jsx("video", { ref: overlayRef, className: "taptapp-ar-overlay-element", src: config.videoSrc, preload: "auto", loop: true, playsInline: true, muted: true, crossOrigin: "anonymous" })) : (_jsx("img", { ref: overlayRef, className: "taptapp-ar-overlay-element", src: config.videoSrc || config.targetImageSrc, crossOrigin: "anonymous", alt: "AR Overlay" })) }), _jsx("style", { children: `
+    return (_jsxs("div", { className: `taptapp-ar-wrapper ${className} ${status}`, style: { position: 'relative', width: '100%', height: '100%', overflow: 'hidden' }, children: [showScanningOverlay && status === "scanning" && (_jsx("div", { className: "taptapp-ar-overlay taptapp-ar-scanning", children: _jsxs("div", { className: "scanning-content", children: [_jsxs("div", { className: "scanning-frame", children: [_jsx("img", { className: "target-preview", src: config.targetImageSrc, alt: "Target", crossOrigin: "anonymous" }), _jsx("div", { className: "scanning-line" })] }), _jsx("p", { className: "scanning-text", children: "Apunta a la imagen para comenzar" })] }) })), showErrorOverlay && status === "error" && (_jsx("div", { className: "taptapp-ar-overlay taptapp-ar-error", children: _jsxs("div", { className: "error-content", children: [_jsx("span", { className: "error-icon", children: "\u26A0\uFE0F" }), _jsx("p", { className: "error-title", children: "No se pudo iniciar AR" }), _jsx("p", { className: "error-text", children: "Verifica los permisos de c\u00E1mara" }), _jsx("button", { className: "retry-btn", onClick: () => window.location.reload(), children: "Reintentar" })] }) })), _jsx("div", { ref: containerRef, className: "taptapp-ar-container", onClick: toggleVideo, style: { width: '100%', height: '100%' }, children: isVideo ? (_jsx("video", { ref: overlayRef, className: "taptapp-ar-overlay-element", src: config.videoSrc, preload: "auto", loop: true, playsInline: true, muted: true, crossOrigin: "anonymous" })) : (_jsx("img", { ref: overlayRef, className: "taptapp-ar-overlay-element", src: config.videoSrc || config.targetImageSrc, crossOrigin: "anonymous", alt: "AR Overlay" })) }), status === "tracking" && (_jsx("div", { className: "taptapp-ar-points-overlay", children: trackedPoints.filter(p => p.reliability > 0.7).map((point, i) => (_jsx("div", { className: "tracking-point", style: {
+                        left: `${point.x}px`,
+                        top: `${point.y}px`,
+                        width: `${(2 + point.reliability * 6) * (0.4 + point.stability * 0.6)}px`,
+                        height: `${(2 + point.reliability * 6) * (0.4 + point.stability * 0.6)}px`,
+                        opacity: (0.3 + (point.reliability * 0.4)) * (0.2 + point.stability * 0.8)
+                    } }, i))) })), _jsx("style", { children: `
                 .taptapp-ar-wrapper {
                     background: #000;
                     color: white;
@@ -96,5 +102,23 @@ export const TaptappAR = ({ config, className = "", showScanningOverlay = true,
                     pointer-events: none;
                     transition: opacity 0.3s ease;
                 }
+                .taptapp-ar-points-overlay {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    width: 100%;
+                    height: 100%;
+                    pointer-events: none;
+                    z-index: 100; /* High z-index to be above overlay */
+                }
+                .tracking-point {
+                    position: absolute;
+                    background: black;
+                    border: 1px solid rgba(255,255,255,0.5); /* Better contrast */
+                    border-radius: 50%;
+                    transform: translate(-50%, -50%);
+                    box-shadow: 0 0 2px rgba(255, 255, 255, 0.8);
+                    pointer-events: none;
+                }
             ` })] }));
 };

package/dist/react/use-ar.d.ts

@@ -1,10 +1,17 @@
 import type { ARConfig } from "./types.js";
 export type ARStatus = "scanning" | "tracking" | "error";
+export interface TrackedPoint {
+    x: number;
+    y: number;
+    reliability: number;
+    stability: number;
+}
 export interface UseARReturn {
     containerRef: React.RefObject<HTMLDivElement>;
     overlayRef: React.RefObject<HTMLVideoElement | HTMLImageElement>;
     status: ARStatus;
     isPlaying: boolean;
     toggleVideo: () => Promise<void>;
+    trackedPoints: TrackedPoint[];
 }
 export declare const useAR: (config: ARConfig) => UseARReturn;

package/dist/react/use-ar.js

@@ -4,6 +4,7 @@ export const useAR = (config) => {
     const overlayRef = useRef(null);
     const [status, setStatus] = useState("scanning");
     const [isPlaying, setIsPlaying] = useState(false);
+    const [trackedPoints, setTrackedPoints] = useState([]);
     const arInstanceRef = useRef(null);
     const toggleVideo = useCallback(async () => {
         const overlay = overlayRef.current;
@@ -39,6 +40,17 @@ export const useAR = (config) => {
                     overlay: overlayRef.current,
                     scale: config.scale,
                     debug: false,
+                    onUpdate: ({ screenCoords, reliabilities, stabilities }) => {
+                        if (screenCoords && reliabilities && stabilities) {
+                            const points = screenCoords.map((p, i) => ({
+                                x: p.x,
+                                y: p.y,
+                                reliability: reliabilities[i],
+                                stability: stabilities[i]
+                            }));
+                            setTrackedPoints(points);
+                        }
+                    },
                     onFound: async ({ targetIndex }) => {
                         console.log(`🎯 Target ${targetIndex} detected!`);
                         if (!isMounted)
@@ -60,6 +72,7 @@ export const useAR = (config) => {
                         if (!isMounted)
                             return;
                         setStatus("scanning");
+                        setTrackedPoints([]);
                         const overlay = overlayRef.current;
                         if (overlay instanceof HTMLVideoElement) {
                             overlay.pause();
@@ -90,6 +103,7 @@ export const useAR = (config) => {
         overlayRef,
         status,
         isPlaying,
-        toggleVideo
+        toggleVideo,
+        trackedPoints
     };
 };

package/package.json

@@ -1,7 +1,29 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.79",
-    "description": "AR Compiler for Node.js and Browser",
+    "version": "1.0.80",
+    "description": "Ultra-fast Augmented Reality (AR) SDK for Node.js and Browser. Image tracking with 100% pure JavaScript, zero-dependencies, and high-performance compilation.",
+    "keywords": [
+        "augmented reality",
+        "ar",
+        "image tracking",
+        "computer vision",
+        "webar",
+        "a-frame",
+        "three.js",
+        "ar.js",
+        "mindar",
+        "tracking",
+        "opencv",
+        "javascript",
+        "webgl",
+        "cross-platform",
+        "no-wasm",
+        "no-tfjs",
+        "webxr",
+        "natural-feature-tracking"
+    ],
+    "author": "Sergio Lázaro <slazaro.dev@gmail.com>",
+    "license": "MIT",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/srsergiolazaro/taptapp-ar.git"

package/src/compiler/controller.ts

@@ -1,12 +1,11 @@
 import { Tracker } from "./tracker/tracker.js";
-import { CropDetector } from "./detector/crop-detector.js";
 import { OfflineCompiler as Compiler } from "./offline-compiler.js";
 import { InputLoader } from "./input-loader.js";
 import { FeatureManager } from "./features/feature-manager.js";
 import { OneEuroFilterFeature } from "./features/one-euro-filter-feature.js";
 import { TemporalFilterFeature } from "./features/temporal-filter-feature.js";
 import { AutoRotationFeature } from "./features/auto-rotation-feature.js";
-import { CropDetectionFeature } from "./features/crop-detection-feature.js";
+import { DetectorLite } from "./detector/detector-lite.js";
 
 let ControllerWorker: any;
 
@@ -26,7 +25,10 @@ ControllerWorker = await getControllerWorker();
 const DEFAULT_FILTER_CUTOFF = 0.5;
 const DEFAULT_FILTER_BETA = 0.1;
 const DEFAULT_WARMUP_TOLERANCE = 2; // Instant detection
-const DEFAULT_MISS_TOLERANCE = 5;   // More grace when partially hidden
+const DEFAULT_MISS_TOLERANCE = 1;   // Immediate response to tracking loss
+const WORKER_TIMEOUT_MS = 1000;    // Prevent worker hangs from killing the loop
+
+let loopIdCounter = 0;
 
 export interface ControllerOptions {
     inputWidth: number;
@@ -62,6 +64,7 @@ class Controller {
     mainThreadMatcher: any;
     mainThreadEstimator: any;
     featureManager: FeatureManager;
+    fullDetector: DetectorLite | null = null;
 
     constructor({
         inputWidth,
@@ -89,7 +92,7 @@ class Controller {
             missTolerance === null ? DEFAULT_MISS_TOLERANCE : missTolerance
         ));
         this.featureManager.addFeature(new AutoRotationFeature());
-        this.featureManager.addFeature(new CropDetectionFeature());
+        // User wants "sin recortes", so we don't add CropDetectionFeature
 
         this.inputLoader = new InputLoader(this.inputWidth, this.inputHeight);
         this.onUpdate = onUpdate;
@@ -97,6 +100,9 @@ class Controller {
         this.worker = worker;
         if (this.worker) this._setupWorkerListener();
 
+        // Moonshot: Full frame detector for better sensitivity
+        this.fullDetector = new DetectorLite(this.inputWidth, this.inputHeight, { useLSH: true });
+
         this.featureManager.init({
             inputWidth: this.inputWidth,
             inputHeight: this.inputHeight,
@@ -219,8 +225,7 @@ class Controller {
 
     dummyRun(input: any) {
         const inputData = this.inputLoader.loadInput(input);
-        const cropFeature = this.featureManager.getFeature<CropDetectionFeature>("crop-detection");
-        cropFeature?.detect(inputData, false);
+        this.fullDetector?.detect(inputData);
         this.tracker!.dummyRun(inputData);
     }
 
@@ -242,8 +247,7 @@ class Controller {
     }
 
     async _detectAndMatch(inputData: any, targetIndexes: number[]) {
-        const cropFeature = this.featureManager.getFeature<CropDetectionFeature>("crop-detection");
-        const { featurePoints } = cropFeature!.detect(inputData, true);
+        const { featurePoints } = this.fullDetector!.detect(inputData);
         const { targetIndex: matchedTargetIndex, modelViewTransform } = await this._workerMatch(
             featurePoints,
             targetIndexes,
@@ -252,22 +256,73 @@ class Controller {
     }
 
     async _trackAndUpdate(inputData: any, lastModelViewTransform: number[][], targetIndex: number) {
-        const { worldCoords, screenCoords } = this.tracker!.track(
+        const { worldCoords, screenCoords, reliabilities, indices = [], octaveIndex = 0 } = this.tracker!.track(
             inputData,
             lastModelViewTransform,
             targetIndex,
         );
-        if (worldCoords.length < 8) return null; // Resynced with Matcher (8 points) to allow initial detection
+
+        const state = this.trackingStates[targetIndex];
+        if (!state.pointStabilities) state.pointStabilities = [];
+        if (!state.pointStabilities[octaveIndex]) {
+            // Initialize stabilities for this octave if not exists
+            const numPoints = (this.tracker as any).prebuiltData[targetIndex][octaveIndex].px.length;
+            state.pointStabilities[octaveIndex] = new Float32Array(numPoints).fill(0.5); // Start at 0.5
+        }
+
+        const stabilities = state.pointStabilities[octaveIndex];
+        const currentStabilities: number[] = [];
+
+        // Update all points in this octave
+        for (let i = 0; i < stabilities.length; i++) {
+            const isTracked = indices.includes(i);
+            if (isTracked) {
+                stabilities[i] = Math.min(1.0, stabilities[i] + 0.35); // Fast recovery (approx 3 frames)
+            } else {
+                stabilities[i] = Math.max(0.0, stabilities[i] - 0.12); // Slightly more forgiving loss
+            }
+        }
+
+        // Collect stabilities and FILTER OUT excessive flickerers (Dead Zone)
+        const filteredWorldCoords = [];
+        const filteredScreenCoords = [];
+        const filteredStabilities = [];
+
+        for (let i = 0; i < indices.length; i++) {
+            const s = stabilities[indices[i]];
+            if (s > 0.3) { // Hard Cutoff: points with <30% stability are ignored
+                filteredWorldCoords.push(worldCoords[i]);
+                filteredScreenCoords.push(screenCoords[i]);
+                filteredStabilities.push(s);
+            }
+        }
+
+        // STRICT QUALITY CHECK: Prevent "sticky" tracking on background noise.
+        // We require a minimum number of high-confidence AND STABLE points.
+        const stableAndReliable = reliabilities.filter((r: number, idx: number) => r > 0.75 && stabilities[indices[idx]] > 0.5).length;
+
+        if (stableAndReliable < 6 || filteredWorldCoords.length < 8) {
+            return { modelViewTransform: null, screenCoords: [], reliabilities: [], stabilities: [] };
+        }
+
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
-            worldCoords,
-            screenCoords,
+            worldCoords: filteredWorldCoords,
+            screenCoords: filteredScreenCoords,
+            stabilities: filteredStabilities
         });
-        return modelViewTransform;
+
+        return {
+            modelViewTransform,
+            screenCoords: filteredScreenCoords,
+            reliabilities: reliabilities.filter((_, idx) => stabilities[indices[idx]] > 0.3),
+            stabilities: filteredStabilities
+        };
     }
 
     processVideo(input: any) {
         if (this.processingVideo) return;
         this.processingVideo = true;
+        const currentLoopId = ++loopIdCounter; // Added for ghost loop prevention
 
         this.trackingStates = [];
         for (let i = 0; i < (this.markerDimensions?.length || 0); i++) {
@@ -282,7 +337,7 @@ class Controller {
 
         const startProcessing = async () => {
             while (true) {
-                if (!this.processingVideo) break;
+                if (!this.processingVideo || currentLoopId !== loopIdCounter) break;
 
                 const inputData = this.inputLoader.loadInput(input);
                 const nTracking = this.trackingStates.reduce((acc, s) => acc + (!!s.isTracking ? 1 : 0), 0);
@@ -309,15 +364,21 @@ class Controller {
                     const trackingState = this.trackingStates[i];
 
                     if (trackingState.isTracking) {
-                        let modelViewTransform = await this._trackAndUpdate(
+                        const result = await this._trackAndUpdate(
                             inputData,
                             trackingState.currentModelViewTransform,
                             i,
                         );
-                        if (modelViewTransform === null) {
+                        if (result === null || result.modelViewTransform === null) {
                             trackingState.isTracking = false;
+                            trackingState.screenCoords = [];
+                            trackingState.reliabilities = [];
+                            trackingState.stabilities = [];
                         } else {
-                            trackingState.currentModelViewTransform = modelViewTransform;
+                            trackingState.currentModelViewTransform = result.modelViewTransform;
+                            trackingState.screenCoords = result.screenCoords;
+                            trackingState.reliabilities = result.reliabilities;
+                            trackingState.stabilities = result.stabilities;
                         }
                     }
 
@@ -332,7 +393,14 @@ class Controller {
 
                     if (trackingState.showing) {
                         const worldMatrix = this._glModelViewMatrix(trackingState.currentModelViewTransform, i);
-                        const filteredMatrix = this.featureManager.applyWorldMatrixFilters(i, worldMatrix);
+
+                        // Calculate confidence score based on point stability
+                        const stabilities = trackingState.stabilities || [];
+                        const avgStability = stabilities.length > 0
+                            ? stabilities.reduce((a: number, b: number) => a + b, 0) / stabilities.length
+                            : 0;
+
+                        const filteredMatrix = this.featureManager.applyWorldMatrixFilters(i, worldMatrix, { stability: avgStability });
                         trackingState.trackingMatrix = filteredMatrix;
 
                         let finalMatrix = [...filteredMatrix];
@@ -349,7 +417,10 @@ class Controller {
                             type: "updateMatrix",
                             targetIndex: i,
                             worldMatrix: finalMatrix,
-                            modelViewTransform: trackingState.currentModelViewTransform
+                            modelViewTransform: trackingState.currentModelViewTransform,
+                            screenCoords: trackingState.screenCoords,
+                            reliabilities: trackingState.reliabilities,
+                            stabilities: trackingState.stabilities
                         });
                     }
                 }
@@ -372,9 +443,8 @@ class Controller {
 
     async detect(input: any) {
         const inputData = this.inputLoader.loadInput(input);
-        const cropFeature = this.featureManager.getFeature<CropDetectionFeature>("crop-detection");
-        const { featurePoints, debugExtra } = cropFeature!.detect(inputData, false);
-        return { featurePoints, debugExtra };
+        const { featurePoints } = this.fullDetector!.detect(inputData);
+        return { featurePoints, debugExtra: {} };
     }
 
     async match(featurePoints: any, targetIndex: number) {
@@ -397,11 +467,18 @@ class Controller {
     _workerMatch(featurePoints: any, targetIndexes: number[]): Promise<any> {
         return new Promise((resolve) => {
             if (!this.worker) {
-                this._matchOnMainThread(featurePoints, targetIndexes).then(resolve);
+                this._matchOnMainThread(featurePoints, targetIndexes).then(resolve).catch(() => resolve({ targetIndex: -1 }));
                 return;
             }
 
+            const timeout = setTimeout(() => {
+                this.workerMatchDone = null;
+                resolve({ targetIndex: -1 });
+            }, WORKER_TIMEOUT_MS);
+
             this.workerMatchDone = (data: any) => {
+                clearTimeout(timeout);
+                this.workerMatchDone = null;
                 resolve({
                     targetIndex: data.targetIndex,
                     modelViewTransform: data.modelViewTransform,
@@ -460,19 +537,27 @@ class Controller {
     _workerTrackUpdate(modelViewTransform: number[][], trackingFeatures: any): Promise<any> {
         return new Promise((resolve) => {
             if (!this.worker) {
-                this._trackUpdateOnMainThread(modelViewTransform, trackingFeatures).then(resolve);
+                this._trackUpdateOnMainThread(modelViewTransform, trackingFeatures).then(resolve).catch(() => resolve(null));
                 return;
             }
 
+            const timeout = setTimeout(() => {
+                this.workerTrackDone = null;
+                resolve(null);
+            }, WORKER_TIMEOUT_MS);
+
             this.workerTrackDone = (data: any) => {
+                clearTimeout(timeout);
+                this.workerTrackDone = null;
                 resolve(data.modelViewTransform);
             };
-            const { worldCoords, screenCoords } = trackingFeatures;
+            const { worldCoords, screenCoords, stabilities } = trackingFeatures;
             this.worker.postMessage({
                 type: "trackUpdate",
                 modelViewTransform,
                 worldCoords,
                 screenCoords,
+                stabilities
             });
         });
     }
@@ -483,11 +568,12 @@ class Controller {
             this.mainThreadEstimator = new Estimator(this.projectionTransform);
         }
 
-        const { worldCoords, screenCoords } = trackingFeatures;
+        const { worldCoords, screenCoords, stabilities } = trackingFeatures;
         return this.mainThreadEstimator.refineEstimate({
             initialModelViewTransform: modelViewTransform,
             worldCoords,
             screenCoords,
+            stabilities
         });
     }
 

package/src/compiler/controller.worker.js

@@ -53,11 +53,12 @@ onmessage = (msg) => {
       break;
 
     case "trackUpdate":
-      const { modelViewTransform, worldCoords, screenCoords } = data;
+      const { modelViewTransform, worldCoords, screenCoords, stabilities } = data;
       const finalModelViewTransform = estimator.refineEstimate({
         initialModelViewTransform: modelViewTransform,
         worldCoords,
         screenCoords,
+        stabilities, // Stability-based weights
       });
       postMessage({
         type: "trackUpdateDone",

package/src/compiler/estimation/refine-estimate.js

@@ -21,6 +21,7 @@ const refineEstimate = ({
   projectionTransform,
   worldCoords,
   screenCoords,
+  stabilities, // Stability-based weighting
 }) => {
   // Question: shall we normlize the screen coords as well?
   // Question: do we need to normlize the scale as well, i.e. make coords from -1 to 1
@@ -74,6 +75,7 @@ const refineEstimate = ({
       projectionTransform,
       worldCoords: normalizedWorldCoords,
       screenCoords,
+      stabilities, // Pass weights to ICP
       inlierProb: inlierProbs[i],
     });
 
@@ -113,6 +115,7 @@ const _doICP = ({
   projectionTransform,
   worldCoords,
   screenCoords,
+  stabilities,
   inlierProb,
 }) => {
   const isRobustMode = inlierProb < 1;
@@ -196,7 +199,13 @@ const _doICP = ({
       });
 
       if (isRobustMode) {
-        const W = (1.0 - E[n] / K2) * (1.0 - E[n] / K2);
+        const robustW = (1.0 - E[n] / K2) * (1.0 - E[n] / K2);
+
+        // Log-weighted stability: suppresses vibrators aggressively but allows recovery
+        const s = stabilities ? stabilities[n] : 1.0;
+        const stabilityW = s * Math.log10(9 * s + 1);
+
+        const W = robustW * stabilityW;
 
         for (let j = 0; j < 2; j++) {
           for (let i = 0; i < 6; i++) {
@@ -206,8 +215,16 @@ const _doICP = ({
         dU.push([dxs[n] * W]);
         dU.push([dys[n] * W]);
       } else {
-        dU.push([dxs[n]]);
-        dU.push([dys[n]]);
+        const s = stabilities ? stabilities[n] : 1.0;
+        const W = s * Math.log10(9 * s + 1);
+
+        for (let j = 0; j < 2; j++) {
+          for (let i = 0; i < 6; i++) {
+            J_U_S[j][i] *= W;
+          }
+        }
+        dU.push([dxs[n] * W]);
+        dU.push([dys[n] * W]);
       }
 
       for (let i = 0; i < J_U_S.length; i++) {

package/src/compiler/features/feature-base.ts

@@ -39,7 +39,7 @@ export interface ControllerFeature extends Feature {
     /**
      * Hook to filter or modify the final world matrix
      */
-    filterWorldMatrix?(targetIndex: number, worldMatrix: number[]): number[];
+    filterWorldMatrix?(targetIndex: number, worldMatrix: number[], context?: any): number[];
 
     /**
      * Hook to decide if a target should be shown

package/src/compiler/features/feature-manager.ts

@@ -27,11 +27,11 @@ export class FeatureManager {
         }
     }
 
-    applyWorldMatrixFilters(targetIndex: number, worldMatrix: number[]): number[] {
+    applyWorldMatrixFilters(targetIndex: number, worldMatrix: number[], context?: any): number[] {
         let result = worldMatrix;
         for (const feature of this.features) {
             if (feature.enabled && feature.filterWorldMatrix) {
-                result = feature.filterWorldMatrix(targetIndex, result);
+                result = feature.filterWorldMatrix(targetIndex, result, context);
             }
         }
         return result;

package/src/compiler/features/one-euro-filter-feature.ts

@@ -30,9 +30,19 @@ export class OneEuroFilterFeature implements ControllerFeature {
         return this.filters[targetIndex];
     }
 
-    filterWorldMatrix(targetIndex: number, worldMatrix: number[]): number[] {
+    filterWorldMatrix(targetIndex: number, worldMatrix: number[], context?: any): number[] {
         if (!this.enabled) return worldMatrix;
+
         const filter = this.getFilter(targetIndex);
+        const stability = context?.stability ?? 1.0;
+
+        // Dynamic Cutoff: If points are very stable (1.0), use higher cutoff (less responsiveness loss).
+        // If points are unstable (0.3), use much lower cutoff (heavy smoothing).
+        // We use a squared curve for even more aggressive suppression of jitter on unstable points.
+        const dynamicMinCutOff = this.minCutOff * (0.05 + Math.pow(stability, 2) * 0.95);
+        filter.minCutOff = dynamicMinCutOff;
+        filter.beta = this.beta;
+
         return filter.filter(Date.now(), worldMatrix);
     }
 

package/src/compiler/matching/matching.js

@@ -235,7 +235,7 @@ const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop
     if (dist !== minD) {
       queue.push({ node: childrenOrIndices[i], d: dist });
     } else {
-      _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop });
+      _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1 });
     }
   }