feat: Implement Tab 2 GPT-based ranging and remove legacy depth calc

LaserPerception/LaserPerception.js

@@ -92,6 +92,9 @@
         }
     };
 
+    // Config: Update track reasoning every 30 frames
+    const REASON_INTERVAL = 30;
+
     // ========= Elements =========
     const sysDot = $("#sys-dot");
     const sysStatus = $("#sys-status");
@@ -2541,6 +2544,7 @@
         state.tracker.beamOn = true;
         state.tracker.lastDetTime = 0;
         state.tracker.lastFrameTime = now();
+        state.tracker.frameCount = 0;
         engageNote.textContent = "Running";
         chipBeam.textContent = "BEAM:ON";
         log("Engage started: tracking enabled, dwell accumulation active.", "g");
@@ -2868,17 +2872,78 @@
     }
 
     function rangeFromArea(track) {
-        const w = videoEngage.videoWidth || state.frame.w;
-        const h = videoEngage.videoHeight || state.frame.h;
-        const a = (track.bbox.w * track.bbox.h) / (w * h);
-        const baseA = Math.max(1e-6, track.baseAreaFrac || a);
-        const rel = Math.sqrt(baseA / Math.max(1e-6, a));
-        return clamp(track.baseRange_m * rel, 80, 16000);
+        // [DELETED] "calculated" depth removed per user request.
+        // Fallback only if GPT hasn't returned yet.
+        return 1000;
+    }
+
+    async function updateTracksWithGPT() {
+        const activeTracks = state.tracker.tracks.filter(t => !t.killed);
+        if (!activeTracks.length) return;
+
+        // Take a snapshot of the current video frame
+        const c = document.createElement("canvas");
+        c.width = videoEngage.videoWidth || state.frame.w;
+        c.height = videoEngage.videoHeight || state.frame.h;
+        const ctx = c.getContext("2d");
+        ctx.drawImage(videoEngage, 0, 0, c.width, c.height);
+
+        const blob = await new Promise(r => c.toBlob(r, 'image/jpeg', 0.85));
+
+        // Prepare tracks payload
+        // Backend expects: [{"id":..., "bbox":[x,y,w,h], "label":...}]
+        const tracksPayload = activeTracks.map(t => ({
+            id: t.id,
+            bbox: [Math.round(t.bbox.x), Math.round(t.bbox.y), Math.round(t.bbox.w), Math.round(t.bbox.h)],
+            label: t.label
+        }));
+
+        const fd = new FormData();
+        fd.append("frame", blob, "scan.jpg");
+        fd.append("tracks", JSON.stringify(tracksPayload));
+
+        log(`Requesting GPT reasoning for ${activeTracks.length} tracks...`, "t");
+
+        try {
+            const res = await fetch(`${state.hf.baseUrl}/reason/track`, {
+                method: "POST",
+                body: fd
+            });
+            if (res.ok) {
+                const data = await res.json(); // { "T01": { "distance_m": 450, "description": "..." }, ... }
+                let updatedCount = 0;
+
+                // Merge into state
+                Object.keys(data).forEach(tid => {
+                    const info = data[tid];
+                    const track = state.tracker.tracks.find(t => t.id === tid);
+                    if (track) {
+                        if (info.distance_m) track.gpt_distance_m = info.distance_m;
+                        if (info.description) track.gpt_description = info.description;
+                        updatedCount++;
+                    }
+                });
+                log(`GPT updated ${updatedCount} tracks.`, "g");
+                renderTrackCards(); // Force refresh UI
+            } else {
+                console.warn("GPT reason failed", res.status);
+            }
+        } catch (e) {
+            console.error("GPT reason error", e);
+        }
     }
 
     function getTrackDisplayRange(track) {
-        const areaRange = rangeFromArea(track);
-        return getDisplayRange(track, areaRange);
+        // Priority: GPT > DepthModel (if enabled) > fallback
+        if (track.gpt_distance_m) {
+            return { range: track.gpt_distance_m, source: "GPT" };
+        }
+        // User requested removing "calculated" depth. 
+        // We still support depth model if valid (optional).
+        if (hasValidDepth(track)) {
+            return { range: track.depth_est_m, source: "Lidar" };
+        }
+        return { range: null, source: "Wait..." };
     }
 
     function dwellFromRange(track, range_m) {
@@ -2896,7 +2961,7 @@
         let best = null;
         state.tracker.tracks.forEach(tr => {
             if (tr.killed) return;
-            const range = rangeFromArea(tr);
+            const range = getTrackDisplayRange(tr).range || 1000;
             const mp = maxPowerAtTarget(range);
             const margin = mp.Ptar - (tr.reqP_kW || 0);
             const dwell = dwellFromRange(tr, range);
@@ -2920,7 +2985,10 @@
         const tr = state.tracker.tracks.find(t => t.id === targetId);
         if (!tr || tr.killed) return;
 
-        const range = rangeFromArea(tr);
+        if (!tr || tr.killed) return;
+
+        const disp = getTrackDisplayRange(tr);
+        const range = disp.range || 1000;
         const reqD = dwellFromRange(tr, range);
 
         // state machine: TRACK -> SETTLE -> FIRE -> ASSESS -> KILL
@@ -3008,8 +3076,15 @@
 
             chipTracks.textContent = `TRACKS:${state.tracker.tracks.filter(t => !t.killed).length}`;
             liveStamp.textContent = new Date().toLocaleTimeString();
+
+            // GPT Update Loop
+            state.tracker.frameCount++;
+            if (state.tracker.frameCount % REASON_INTERVAL === 0) {
+                updateTracksWithGPT().catch(e => console.error(e));
+            }
         }
         tick();
+
     }
 
     function renderEngageOverlay() {
@@ -3036,8 +3111,8 @@
             const ax = b.x + b.w * tr.aimRel.relx;
             const ay = b.y + b.h * tr.aimRel.rely;
 
-            const range = rangeFromArea(tr);
             const displayRange = getTrackDisplayRange(tr);
+            const range = displayRange.range || 1000;
             const reqD = dwellFromRange(tr, range);
 
             const mp = maxPowerAtTarget(range);
@@ -3109,8 +3184,8 @@
         }
 
         alive.forEach(tr => {
-            const range = rangeFromArea(tr);
             const displayRange = getTrackDisplayRange(tr);
+            const range = displayRange.range || 1000;
             const rangeTxt = Number.isFinite(displayRange.range)
                 ? `${Math.round(displayRange.range)}m (${displayRange.source})`
                 : "—";
@@ -3346,7 +3421,7 @@
     // Start loop immediately
     requestAnimationFrame(renderFrameRadar);
 
-// ========= Radar rendering (Tab 2) - Aligned with Tab 1 Scale/FOV =========
+    // ========= Radar rendering (Tab 2) - Aligned with Tab 1 Scale/FOV =========
     function renderRadar() {
         const ctx = radarCanvas.getContext("2d");
         const rect = radarCanvas.getBoundingClientRect();
@@ -3384,7 +3459,7 @@
         // Sweep Animation
         const t = now() / 1500; // Match Tab 1 speed (slower)
         const ang = (t * (Math.PI * 2)) % (Math.PI * 2);
-        
+
         // Gradient Sweep
         const grad = ctx.createConicGradient(ang + Math.PI / 2, cx, cy);
         grad.addColorStop(0, "transparent");
@@ -3419,12 +3494,11 @@
         const tracks = state.tracker.tracks;
         tracks.forEach(tr => {
             // Range Logic (Matches Tab 1)
-            const areaRange = rangeFromArea(tr);
             const displayRange = getTrackDisplayRange(tr);
-            
+
             let dist = 3000;
             if (Number.isFinite(displayRange.range)) dist = displayRange.range;
-            else dist = areaRange; // fallback
+            // else remain at default "unknown" distance (far out) until GPT returns
 
             // Scale: 0 -> 1500m (Matches Tab 1)
             const maxRangeM = 1500;
@@ -3436,7 +3510,7 @@
             const vw = videoEngage.videoWidth || state.frame.w || 1280;
             const bx = tr.bbox.x + tr.bbox.w * 0.5;
             const tx = (bx / vw) - 0.5; // -0.5 (left) to 0.5 (right)
-            
+
             const fovRad = (60 * Math.PI) / 180;
             const angle = (-Math.PI / 2) + (tx * fovRad);
 

app.py

@@ -54,6 +54,7 @@ from jobs.storage import (
     get_job_storage,
     get_output_video_path,
 )
+from utils.gpt_distance import estimate_distance_gpt
 
 logging.basicConfig(level=logging.INFO)
 
@@ -564,5 +565,42 @@ async def stream_video(job_id: str):
     )
 
 
+@app.post("/reason/track")
+async def reason_track(
+    frame: UploadFile = File(...),
+    tracks: str = Form(...)  # JSON string of tracks: [{"id": "T01", "bbox": [x,y,w,h], "label": "car"}, ...]
+):
+    """
+    Reason about specific tracks in a frame using GPT.
+    Returns distance and description for each object ID.
+    """
+    import json
+    try:
+        input_path = _save_upload_to_tmp(frame)
+    except Exception:
+        raise HTTPException(status_code=500, detail="Failed to save uploaded frame")
+
+    try:
+        track_list = json.loads(tracks)
+    except json.JSONDecodeError:
+        _safe_delete(input_path)
+        raise HTTPException(status_code=400, detail="Invalid tracks JSON")
+
+    # Run GPT estimation
+    # This is blocking, but that's expected for this endpoint structure. 
+    # For high concurrency, might want to offload to threadpool or async wrapper.
+    try:
+        # estimate_distance_gpt reads the file from disk
+        results = await asyncio.to_thread(estimate_distance_gpt, input_path, track_list)
+    except Exception as e:
+        logging.exception("GPT reasoning failed")
+        _safe_delete(input_path)
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    _safe_delete(input_path)
+    return results
+
+
+
 if __name__ == "__main__":
     uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)