Fix tracking bugs: remove COCO fallback in HF mode, smooth velocity, and add track pruning

LaserPerception/LaserPerception.js

@@ -2697,24 +2697,15 @@
             return [];
         }
         if (isHfMode(mode)) {
-            if (!state.detector.hfTrackingWarned) {
-                state.detector.hfTrackingWarned = true;
-                log("HF mode active: Using local COCO model for live tracking (fallback).", "t");
-            }
-            // Fallback to COCO for live tracking so Radar/Cards aren't empty
-            await ensureCocoDetector();
-            if (state.detector.model) {
-                try {
-                    let preds = await state.detector.model.detect(videoEngage);
-                    return preds
-                        .filter(p => p.score >= 0.45)
-                        .slice(0, 18)
-                        .map(p => ({ bbox: p.bbox, class: p.class, score: p.score }));
-                } catch (err) {
-                    // ignore security error for fallback
-                    return [];
-                }
-            }
+            // In HF mode, we DO NOT fall back to local COCO for tracking.
+            // Why? Because local COCO will overwrite high-quality labels (e.g. "drone") 
+            // with generic ones ("airplane"), breaking the user experience.
+            // Instead, we rely on the tracker's predictive coasting (predictTracks)
+            // or wait for sparse updates if we implement backend streaming later.
+
+            // For now, return empty to prevent label pollution.
+            // The tracker will maintain existing tracks via coasting/prediction 
+            // until they time out or we get a new "Reason" update.
             return [];
         }
         if (mode === "coco") {
@@ -2770,72 +2761,94 @@
                     bestIdx = i;
                 }
             }
-            if (best && bestI >= 0.18) {
+            // Strict matching threshold
+            if (best && bestI >= 0.25) {
                 used.add(bestIdx);
 
-                // velocity estimate
+                // Velocity with Exponential Moving Average (EMA) for smoothing
                 const cx0 = tr.bbox.x + tr.bbox.w * 0.5;
                 const cy0 = tr.bbox.y + tr.bbox.h * 0.5;
                 const cx1 = best.bbox.x + best.bbox.w * 0.5;
                 const cy1 = best.bbox.y + best.bbox.h * 0.5;
-                tr.vx = (cx1 - cx0) / Math.max(1e-6, dtSec);
-                tr.vy = (cy1 - cy0) / Math.max(1e-6, dtSec);
+
+                const rawVx = (cx1 - cx0) / Math.max(1e-3, dtSec);
+                const rawVy = (cy1 - cy0) / Math.max(1e-3, dtSec);
+
+                // Alpha of 0.3 means 30% new value, 70% history
+                tr.vx = tr.vx * 0.7 + rawVx * 0.3;
+                tr.vy = tr.vy * 0.7 + rawVy * 0.3;
 
                 // smooth bbox update
-                tr.bbox.x = lerp(tr.bbox.x, best.bbox.x, 0.65);
-                tr.bbox.y = lerp(tr.bbox.y, best.bbox.y, 0.65);
-                tr.bbox.w = lerp(tr.bbox.w, best.bbox.w, 0.55);
-                tr.bbox.h = lerp(tr.bbox.h, best.bbox.h, 0.55);
+                tr.bbox.x = lerp(tr.bbox.x, best.bbox.x, 0.7);
+                tr.bbox.y = lerp(tr.bbox.y, best.bbox.y, 0.7);
+                tr.bbox.w = lerp(tr.bbox.w, best.bbox.w, 0.6);
+                tr.bbox.h = lerp(tr.bbox.h, best.bbox.h, 0.6);
+
+                // Logic: Only update label if the new detection is highly confident 
+                // AND the current track doesn't have a "premium" label (like 'drone').
+                // This prevents COCO's 'airplane' from overwriting a custom 'drone' label.
+                const protectedLabels = ["drone", "uav", "missile"];
+                const isProtected = protectedLabels.some(l => (tr.label || "").toLowerCase().includes(l));
+
+                if (!isProtected || (best.label && protectedLabels.some(l => best.label.toLowerCase().includes(l)))) {
+                    tr.label = best.label || tr.label;
+                }
 
-                tr.label = best.label || tr.label;
                 tr.score = best.score || tr.score;
                 // Update depth visualization (not for distance)
                 if (Number.isFinite(best.depth_rel)) {
                     tr.depth_rel = best.depth_rel;
                 }
                 tr.lastSeen = now();
+            } else {
+                // Decay velocity if not seen to prevent "coasting" into infinity
+                tr.vx *= 0.9;
+                tr.vy *= 0.9;
             }
         }
 
         // add unmatched detections as new tracks (optional)
-        for (let i = 0; i < detObjs.length; i++) {
-            if (used.has(i)) continue;
-            // create new track only if big enough (avoid clutter)
-            const a = detObjs[i].bbox.w * detObjs[i].bbox.h;
-            if (a < (w * h) * 0.0025) continue;
-
-            const newId = `T${String(state.tracker.nextId++).padStart(2, "0")}`;
-            const ap = defaultAimpoint(detObjs[i].label);
-            tracks.push({
-                id: newId,
-                label: detObjs[i].label,
-                bbox: { ...detObjs[i].bbox },
-                score: detObjs[i].score,
-                aimRel: { relx: ap.relx, rely: ap.rely, label: ap.label },
-                baseAreaFrac: (detObjs[i].bbox.w * detObjs[i].bbox.h) / (w * h),
-                baseRange_m: +rangeBase.value,
-                baseDwell_s: 5.5,
-                reqP_kW: 42,
-                // Depth visualization only, GPT handles distance
-                depth_rel: detObjs[i].depth_rel,
-                // GPT properties (will be populated by updateTracksWithGPT)
-                gpt_distance_m: null,
-                gpt_direction: null,
-                gpt_description: null,
-                // Track state
-                lastSeen: now(),
-                vx: 0, vy: 0,
-                dwellAccum: 0,
-                killed: false,
-                state: "TRACK",
-                assessT: 0
-            });
-            log(`New track created: ${newId} (${detObjs[i].label})`, "t");
+        // Limit total tracks to prevent memory leaks/ui lag
+        if (tracks.length < 50) {
+            for (let i = 0; i < detObjs.length; i++) {
+                if (used.has(i)) continue;
+                // create new track only if big enough (avoid clutter)
+                const a = detObjs[i].bbox.w * detObjs[i].bbox.h;
+                if (a < (w * h) * 0.0025) continue;
+
+                const newId = `T${String(state.tracker.nextId++).padStart(2, "0")}`;
+                const ap = defaultAimpoint(detObjs[i].label);
+                tracks.push({
+                    id: newId,
+                    label: detObjs[i].label,
+                    bbox: { ...detObjs[i].bbox },
+                    score: detObjs[i].score,
+                    aimRel: { relx: ap.relx, rely: ap.rely, label: ap.label },
+                    baseAreaFrac: (detObjs[i].bbox.w * detObjs[i].bbox.h) / (w * h),
+                    baseRange_m: +rangeBase.value,
+                    baseDwell_s: 5.5,
+                    reqP_kW: 42,
+                    // Depth visualization only, GPT handles distance
+                    depth_rel: detObjs[i].depth_rel,
+                    // GPT properties (will be populated by updateTracksWithGPT)
+                    gpt_distance_m: null,
+                    gpt_direction: null,
+                    gpt_description: null,
+                    // Track state
+                    lastSeen: now(),
+                    vx: 0, vy: 0,
+                    dwellAccum: 0,
+                    killed: false,
+                    state: "TRACK",
+                    assessT: 0
+                });
+                log(`New track created: ${newId} (${detObjs[i].label})`, "t");
+            }
         }
 
         // prune old tracks if they disappear
         const tNow = now();
-        state.tracker.tracks = tracks.filter(tr => (tNow - tr.lastSeen) < 2200 || tr.killed);
+        state.tracker.tracks = tracks.filter(tr => (tNow - tr.lastSeen) < 1500 || tr.killed);
     }
 
     function predictTracks(dtSec) {