chore: remove dead code and unused frontend modules

frontend/js/core/video.js

@@ -186,9 +186,7 @@ APP.core.video.unloadVideo = async function (options = {}) {
     APP.core.video.clearCanvas($("#engageOverlay"));
 
     // Re-render UI components
-    if (APP.ui.radar.renderFrameRadar) APP.ui.radar.renderFrameRadar();
     if (APP.ui.cards.renderFrameTrackList) APP.ui.cards.renderFrameTrackList();
-    if (APP.ui.trade.renderTrade) APP.ui.trade.renderTrade();
 
     setStatus("warn", "STANDBY · No video loaded");
     log("Video unloaded. Demo reset.", "w");
@@ -621,4 +619,3 @@ APP.core.video.displayFirstFrameWithDepth = function () {
         APP.core.video.drawFirstFrame();
     }
 };
-

frontend/js/ui/features.js

@@ -1 +0,0 @@
-APP.ui.features = {};

frontend/js/ui/intel.js

@@ -1,118 +0,0 @@
-// Intel Summary Module - Mission intel generation and display
-APP.ui.intel = {};
-
-APP.ui.intel.setIntelStatus = function (kind, text) {
-    const { $ } = APP.core.utils;
-    const intelStamp = $("#intelStamp");
-    const intelDot = $("#intelDot");
-
-    if (!intelStamp || !intelDot) return;
-
-    intelStamp.innerHTML = text;
-    intelDot.className = "dot" + (kind === "warn" ? " warn" : (kind === "bad" ? " bad" : ""));
-    intelDot.style.width = "7px";
-    intelDot.style.height = "7px";
-    intelDot.style.boxShadow = "none";
-};
-
-APP.ui.intel.setIntelThumb = function (i, dataUrl) {
-    const { $ } = APP.core.utils;
-    const thumbs = [$("#intelThumb0"), $("#intelThumb1"), $("#intelThumb2")];
-    const img = thumbs[i];
-    if (!img) return;
-    img.src = dataUrl || "";
-};
-
-APP.ui.intel.resetIntelUI = function () {
-    const { $ } = APP.core.utils;
-    const intelSummaryBox = $("#intelSummaryBox");
-
-    if (!intelSummaryBox) return;
-    intelSummaryBox.innerHTML = 'Upload a video, then click <b>Detect</b> to generate an unbiased scene summary.';
-    APP.ui.intel.setIntelStatus("warn", "Idle");
-    APP.ui.intel.setIntelThumb(0, "");
-    APP.ui.intel.setIntelThumb(1, "");
-    APP.ui.intel.setIntelThumb(2, "");
-};
-
-// External hook for intel summary (can be replaced by user)
-APP.ui.intel.externalIntel = async function (frames) {
-    console.log("externalIntel called with", frames.length, "frames");
-    return "Video processed. No external intel provider connected.";
-};
-
-APP.ui.intel.computeIntelSummary = async function () {
-    const { state } = APP.core;
-    const { $ } = APP.core.utils;
-    const { log } = APP.ui.logging;
-
-    const intelSummaryBox = $("#intelSummaryBox");
-    const videoHidden = $("#videoHidden");
-    const videoEngage = $("#videoEngage");
-
-    if (!intelSummaryBox) return;
-    if (!state.videoLoaded) {
-        APP.ui.intel.resetIntelUI();
-        return;
-    }
-    if (state.intelBusy) return;
-
-    state.intelBusy = true;
-    APP.ui.intel.setIntelStatus("warn", "Generating…");
-    intelSummaryBox.textContent = "Sampling frames and running analysis…";
-
-    try {
-        const videoEl = videoHidden || videoEngage;
-        const dur = videoEl ? (videoEl.duration || 0) : 0;
-        const times = [0, dur ? dur * 0.33 : 1, dur ? dur * 0.66 : 2];
-        const frames = [];
-
-        for (let i = 0; i < times.length; i++) {
-            await APP.core.video.seekTo(videoEl, times[i]);
-
-            const canvas = document.createElement("canvas");
-            canvas.width = 640;
-            canvas.height = 360;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(videoEl, 0, 0, canvas.width, canvas.height);
-            const dataUrl = canvas.toDataURL("image/jpeg", 0.6);
-            frames.push(dataUrl);
-
-            try {
-                APP.ui.intel.setIntelThumb(i, dataUrl);
-            } catch (_) { }
-        }
-
-        const summary = await APP.ui.intel.externalIntel(frames);
-
-        intelSummaryBox.textContent = summary;
-        APP.ui.intel.setIntelStatus("good", `Updated · ${new Date().toLocaleTimeString()}`);
-    } catch (err) {
-        APP.ui.intel.setIntelStatus("bad", "Summary unavailable");
-        intelSummaryBox.textContent = `Unable to generate summary: ${err.message}`;
-        console.error(err);
-    } finally {
-        state.intelBusy = false;
-    }
-};
-
-// Render mission context (if applicable)
-APP.ui.intel.renderMissionContext = function () {
-    const { state } = APP.core;
-    const { $ } = APP.core.utils;
-
-    const missionClassesEl = $("#missionClasses");
-    const missionIdEl = $("#missionId");
-
-    if (missionClassesEl) {
-        if (state.hf.queries && state.hf.queries.length > 0) {
-            missionClassesEl.textContent = state.hf.queries.join(", ");
-        } else {
-            missionClassesEl.textContent = "All objects (no filter)";
-        }
-    }
-
-    if (missionIdEl) {
-        missionIdEl.textContent = state.hf.missionId || "—";
-    }
-};

frontend/js/ui/radar.js

@@ -1,668 +0,0 @@
-APP.ui.radar = {};
-
-// Military color palette
-APP.ui.radar.colors = {
-    background: "#0a0d0f",
-    gridPrimary: "rgba(0, 255, 136, 0.3)",
-    gridSecondary: "rgba(0, 255, 136, 0.12)",
-    gridTertiary: "rgba(0, 255, 136, 0.06)",
-    sweepLine: "rgba(0, 255, 136, 0.9)",
-    sweepGlow: "rgba(0, 255, 136, 0.4)",
-    sweepTrail: "rgba(0, 255, 136, 0.15)",
-    text: "rgba(0, 255, 136, 0.9)",
-    textDim: "rgba(0, 255, 136, 0.5)",
-    ownship: "#00ff88",
-    hostile: "#ff3344",
-    neutral: "#ffaa00",
-    friendly: "#00aaff",
-    selected: "#ffffff",
-    dataBox: "rgba(0, 20, 10, 0.92)",
-    dataBorder: "rgba(0, 255, 136, 0.6)"
-};
-
-APP.ui.radar.render = function (canvasId, trackSource, options = {}) {
-    const isStatic = options.static || false;
-    const { state } = APP.core;
-    const { clamp, now, $ } = APP.core.utils;
-    const canvas = $(`#${canvasId}`);
-    const colors = APP.ui.radar.colors;
-
-    if (!canvas) return;
-    const ctx = canvas.getContext("2d");
-    const rect = canvas.getBoundingClientRect();
-    const dpr = devicePixelRatio || 1;
-
-    // Resize if needed
-    const targetW = Math.max(1, Math.floor(rect.width * dpr));
-    const targetH = Math.max(1, Math.floor(rect.height * dpr));
-    if (canvas.width !== targetW || canvas.height !== targetH) {
-        canvas.width = targetW;
-        canvas.height = targetH;
-    }
-
-    const w = canvas.width, h = canvas.height;
-    const cx = w * 0.5, cy = h * 0.5;
-    const R = Math.min(w, h) * 0.44;
-    const maxRangeM = 1500;
-
-    ctx.clearRect(0, 0, w, h);
-
-    // --- Control Knobs ---
-    const histSlider = document.getElementById("radarHistoryLen");
-    const futSlider = document.getElementById("radarFutureLen");
-    if (histSlider && document.getElementById("radarHistoryVal")) {
-        document.getElementById("radarHistoryVal").textContent = histSlider.value;
-    }
-    if (futSlider && document.getElementById("radarFutureVal")) {
-        document.getElementById("radarFutureVal").textContent = futSlider.value;
-    }
-    const maxHist = histSlider ? parseInt(histSlider.value, 10) : 30;
-    const maxFut = futSlider ? parseInt(futSlider.value, 10) : 30;
-
-    // ===========================================
-    // 1. BACKGROUND - Dark tactical display
-    // ===========================================
-    ctx.fillStyle = colors.background;
-    ctx.fillRect(0, 0, w, h);
-
-    // Subtle noise/static effect
-    ctx.globalAlpha = 0.03;
-    for (let i = 0; i < 100; i++) {
-        const nx = Math.random() * w;
-        const ny = Math.random() * h;
-        ctx.fillStyle = "#00ff88";
-        ctx.fillRect(nx, ny, 1, 1);
-    }
-    ctx.globalAlpha = 1;
-
-    // Scanline effect
-    ctx.strokeStyle = "rgba(0, 255, 136, 0.02)";
-    ctx.lineWidth = 1;
-    for (let y = 0; y < h; y += 3) {
-        ctx.beginPath();
-        ctx.moveTo(0, y);
-        ctx.lineTo(w, y);
-        ctx.stroke();
-    }
-
-    // ===========================================
-    // 2. OUTER BEZEL / FRAME
-    // ===========================================
-    // Outer border ring
-    ctx.strokeStyle = colors.gridPrimary;
-    ctx.lineWidth = 2;
-    ctx.beginPath();
-    ctx.arc(cx, cy, R + 8, 0, Math.PI * 2);
-    ctx.stroke();
-
-    // Inner border ring
-    ctx.strokeStyle = colors.gridSecondary;
-    ctx.lineWidth = 1;
-    ctx.beginPath();
-    ctx.arc(cx, cy, R + 3, 0, Math.PI * 2);
-    ctx.stroke();
-
-    // Corner brackets
-    const bracketSize = 15;
-    const bracketOffset = R + 20;
-    ctx.strokeStyle = colors.gridPrimary;
-    ctx.lineWidth = 2;
-
-    // Top-left
-    ctx.beginPath();
-    ctx.moveTo(cx - bracketOffset, cy - bracketOffset + bracketSize);
-    ctx.lineTo(cx - bracketOffset, cy - bracketOffset);
-    ctx.lineTo(cx - bracketOffset + bracketSize, cy - bracketOffset);
-    ctx.stroke();
-
-    // Top-right
-    ctx.beginPath();
-    ctx.moveTo(cx + bracketOffset - bracketSize, cy - bracketOffset);
-    ctx.lineTo(cx + bracketOffset, cy - bracketOffset);
-    ctx.lineTo(cx + bracketOffset, cy - bracketOffset + bracketSize);
-    ctx.stroke();
-
-    // Bottom-left
-    ctx.beginPath();
-    ctx.moveTo(cx - bracketOffset, cy + bracketOffset - bracketSize);
-    ctx.lineTo(cx - bracketOffset, cy + bracketOffset);
-    ctx.lineTo(cx - bracketOffset + bracketSize, cy + bracketOffset);
-    ctx.stroke();
-
-    // Bottom-right
-    ctx.beginPath();
-    ctx.moveTo(cx + bracketOffset - bracketSize, cy + bracketOffset);
-    ctx.lineTo(cx + bracketOffset, cy + bracketOffset);
-    ctx.lineTo(cx + bracketOffset, cy + bracketOffset - bracketSize);
-    ctx.stroke();
-
-    // ===========================================
-    // 3. RANGE RINGS with labels
-    // ===========================================
-    const rangeRings = [
-        { frac: 0.25, label: "375m" },
-        { frac: 0.5, label: "750m" },
-        { frac: 0.75, label: "1125m" },
-        { frac: 1.0, label: "1500m" }
-    ];
-
-    rangeRings.forEach((ring, i) => {
-        const ringR = R * ring.frac;
-
-        // Ring line
-        ctx.strokeStyle = i === 3 ? colors.gridPrimary : colors.gridSecondary;
-        ctx.lineWidth = i === 3 ? 1.5 : 1;
-        ctx.beginPath();
-        ctx.arc(cx, cy, ringR, 0, Math.PI * 2);
-        ctx.stroke();
-
-        // Tick marks on outer ring
-        if (i === 3) {
-            for (let deg = 0; deg < 360; deg += 5) {
-                const rad = (deg - 90) * Math.PI / 180;
-                const tickLen = deg % 30 === 0 ? 8 : (deg % 10 === 0 ? 5 : 2);
-                const x1 = cx + Math.cos(rad) * ringR;
-                const y1 = cy + Math.sin(rad) * ringR;
-                const x2 = cx + Math.cos(rad) * (ringR + tickLen);
-                const y2 = cy + Math.sin(rad) * (ringR + tickLen);
-
-                ctx.strokeStyle = deg % 30 === 0 ? colors.gridPrimary : colors.gridTertiary;
-                ctx.lineWidth = deg % 30 === 0 ? 1.5 : 0.5;
-                ctx.beginPath();
-                ctx.moveTo(x1, y1);
-                ctx.lineTo(x2, y2);
-                ctx.stroke();
-            }
-        }
-
-        // Range labels (on right side)
-        ctx.font = "bold 9px 'Courier New', monospace";
-        ctx.fillStyle = colors.textDim;
-        ctx.textAlign = "left";
-        ctx.textBaseline = "middle";
-        ctx.fillText(ring.label, cx + ringR + 4, cy);
-    });
-
-    // ===========================================
-    // 4. COMPASS ROSE / BEARING LINES
-    // ===========================================
-    // Cardinal directions with labels
-    const cardinals = [
-        { deg: 0, label: "N", primary: true },
-        { deg: 45, label: "NE", primary: false },
-        { deg: 90, label: "E", primary: true },
-        { deg: 135, label: "SE", primary: false },
-        { deg: 180, label: "S", primary: true },
-        { deg: 225, label: "SW", primary: false },
-        { deg: 270, label: "W", primary: true },
-        { deg: 315, label: "NW", primary: false }
-    ];
-
-    cardinals.forEach(dir => {
-        const rad = (dir.deg - 90) * Math.PI / 180;
-        const x1 = cx + Math.cos(rad) * 12;
-        const y1 = cy + Math.sin(rad) * 12;
-        const x2 = cx + Math.cos(rad) * R;
-        const y2 = cy + Math.sin(rad) * R;
-
-        // Spoke line
-        ctx.strokeStyle = dir.primary ? colors.gridSecondary : colors.gridTertiary;
-        ctx.lineWidth = dir.primary ? 1 : 0.5;
-        ctx.setLineDash(dir.primary ? [] : [2, 4]);
-        ctx.beginPath();
-        ctx.moveTo(x1, y1);
-        ctx.lineTo(x2, y2);
-        ctx.stroke();
-        ctx.setLineDash([]);
-
-        // Cardinal label
-        const labelR = R + 18;
-        const lx = cx + Math.cos(rad) * labelR;
-        const ly = cy + Math.sin(rad) * labelR;
-
-        ctx.font = dir.primary ? "bold 11px 'Courier New', monospace" : "9px 'Courier New', monospace";
-        ctx.fillStyle = dir.primary ? colors.text : colors.textDim;
-        ctx.textAlign = "center";
-        ctx.textBaseline = "middle";
-        ctx.fillText(dir.label, lx, ly);
-    });
-
-    // ===========================================
-    // 5. SWEEP ANIMATION (skip for static mode)
-    // ===========================================
-    if (!isStatic) {
-        const t = now() / 2000; // Slower sweep
-        const sweepAng = (t * (Math.PI * 2)) % (Math.PI * 2);
-
-        // Sweep trail (gradient arc)
-        const trailLength = Math.PI * 0.4;
-        const trailGrad = ctx.createConicGradient(sweepAng - trailLength + Math.PI / 2, cx, cy);
-        trailGrad.addColorStop(0, "transparent");
-        trailGrad.addColorStop(0.7, "rgba(0, 255, 136, 0.0)");
-        trailGrad.addColorStop(1, "rgba(0, 255, 136, 0.12)");
-
-        ctx.fillStyle = trailGrad;
-        ctx.beginPath();
-        ctx.arc(cx, cy, R, 0, Math.PI * 2);
-        ctx.fill();
-
-        // Sweep line with glow
-        ctx.shadowBlur = 15;
-        ctx.shadowColor = colors.sweepGlow;
-        ctx.strokeStyle = colors.sweepLine;
-        ctx.lineWidth = 2;
-        ctx.beginPath();
-        ctx.moveTo(cx, cy);
-        ctx.lineTo(cx + Math.cos(sweepAng) * R, cy + Math.sin(sweepAng) * R);
-        ctx.stroke();
-        ctx.shadowBlur = 0;
-    }
-
-    // ===========================================
-    // 6. OWNSHIP (Center)
-    // ===========================================
-    // Ownship symbol - aircraft shape
-    ctx.fillStyle = colors.ownship;
-    ctx.shadowBlur = 8;
-    ctx.shadowColor = colors.ownship;
-
-    ctx.beginPath();
-    ctx.moveTo(cx, cy - 8);      // Nose
-    ctx.lineTo(cx + 5, cy + 4);  // Right wing
-    ctx.lineTo(cx + 2, cy + 2);
-    ctx.lineTo(cx + 2, cy + 8);  // Right tail
-    ctx.lineTo(cx, cy + 5);
-    ctx.lineTo(cx - 2, cy + 8);  // Left tail
-    ctx.lineTo(cx - 2, cy + 2);
-    ctx.lineTo(cx - 5, cy + 4);  // Left wing
-    ctx.closePath();
-    ctx.fill();
-    ctx.shadowBlur = 0;
-
-    // Ownship pulse ring (skip for static mode)
-    if (!isStatic) {
-        const pulsePhase = (now() / 1000) % 1;
-        const pulseR = 10 + pulsePhase * 15;
-        ctx.strokeStyle = `rgba(0, 255, 136, ${0.5 - pulsePhase * 0.5})`;
-        ctx.lineWidth = 1;
-        ctx.beginPath();
-        ctx.arc(cx, cy, pulseR, 0, Math.PI * 2);
-        ctx.stroke();
-    } else {
-        // Static ring for static mode
-        ctx.strokeStyle = `rgba(0, 255, 136, 0.4)`;
-        ctx.lineWidth = 1;
-        ctx.beginPath();
-        ctx.arc(cx, cy, 12, 0, Math.PI * 2);
-        ctx.stroke();
-    }
-
-    // ===========================================
-    // 7. RENDER TRACKS / TARGETS
-    // ===========================================
-    const source = trackSource || state.detections;
-    const fovRad = (60 * Math.PI) / 180;
-
-    if (source && source.length > 0) {
-        source.forEach((det, idx) => {
-            // Calculate range
-            let rPx;
-            let dist = 3000;
-
-            if (det.depth_valid && det.depth_rel != null) {
-                rPx = (det.depth_rel * 0.9 + 0.1) * R;
-                dist = det.depth_est_m || 3000;
-            } else {
-                if (det.gpt_distance_m) {
-                    dist = det.gpt_distance_m;
-                } else if (det.baseRange_m) {
-                    dist = det.baseRange_m;
-                }
-                rPx = (clamp(dist, 0, maxRangeM) / maxRangeM) * R;
-            }
-
-            // Calculate bearing from bbox
-            const bx = det.bbox.x + det.bbox.w * 0.5;
-            let tx = 0;
-            if (bx <= 2.0) {
-                tx = bx - 0.5;
-            } else {
-                const fw = state.frame.w || 1280;
-                tx = (bx / fw) - 0.5;
-            }
-            const angle = (-Math.PI / 2) + (tx * fovRad);
-
-            // Target position
-            const px = cx + Math.cos(angle) * rPx;
-            const py = cy + Math.sin(angle) * rPx;
-
-            const isSelected = (state.selectedId === det.id) || (state.tracker.selectedTrackId === det.id);
-
-            // Determine threat color
-            let threatColor = colors.hostile; // Default hostile (red)
-            const label = (det.label || "").toLowerCase();
-            if (label.includes('person')) threatColor = colors.neutral;
-            if (label.includes('friendly')) threatColor = colors.friendly;
-            if (isSelected) threatColor = colors.selected;
-
-            // Target glow for all targets
-            ctx.shadowBlur = isSelected ? 15 : 8;
-            ctx.shadowColor = threatColor;
-
-            // ===========================================
-            // TARGET SYMBOL - Military bracket style
-            // ===========================================
-            ctx.save();
-            ctx.translate(px, py);
-
-            // Rotation based on heading
-            let rotation = -Math.PI / 2;
-            if (det.angle_deg !== undefined) {
-                rotation = det.angle_deg * (Math.PI / 180);
-            }
-            ctx.rotate(rotation);
-
-            const size = isSelected ? 16 : 12;
-
-            // Draw target - larger triangle shape
-            ctx.strokeStyle = threatColor;
-            ctx.fillStyle = threatColor;
-            ctx.lineWidth = isSelected ? 2.5 : 2;
-
-            // Triangle pointing in direction of travel
-            ctx.beginPath();
-            ctx.moveTo(size, 0);              // Front tip
-            ctx.lineTo(-size * 0.6, -size * 0.5); // Top left
-            ctx.lineTo(-size * 0.4, 0);       // Back indent
-            ctx.lineTo(-size * 0.6, size * 0.5);  // Bottom left
-            ctx.closePath();
-            ctx.fill();
-
-            // Outline for better visibility
-            ctx.strokeStyle = isSelected ? "#ffffff" : "rgba(0, 0, 0, 0.5)";
-            ctx.lineWidth = 1;
-            ctx.stroke();
-
-            ctx.restore();
-            ctx.shadowBlur = 0;
-
-            // ===========================================
-            // TARGET ID LABEL (always show)
-            // ===========================================
-            ctx.font = "bold 9px 'Courier New', monospace";
-            ctx.fillStyle = threatColor;
-            ctx.textAlign = "left";
-            ctx.textBaseline = "middle";
-            ctx.fillText(det.id, px + 12, py - 2);
-
-            // ===========================================
-            // SELECTED TARGET - Full data display
-            // ===========================================
-            if (isSelected) {
-                // Targeting brackets around selected target
-                const bracketS = 18;
-                ctx.strokeStyle = colors.selected;
-                ctx.lineWidth = 1.5;
-
-                // Animated bracket expansion (static for static mode)
-                const bracketPulse = isStatic ? 0 : Math.sin(now() / 200) * 2;
-                const bOff = bracketS + bracketPulse;
-
-                // Top-left bracket
-                ctx.beginPath();
-                ctx.moveTo(px - bOff, py - bOff + 6);
-                ctx.lineTo(px - bOff, py - bOff);
-                ctx.lineTo(px - bOff + 6, py - bOff);
-                ctx.stroke();
-
-                // Top-right bracket
-                ctx.beginPath();
-                ctx.moveTo(px + bOff - 6, py - bOff);
-                ctx.lineTo(px + bOff, py - bOff);
-                ctx.lineTo(px + bOff, py - bOff + 6);
-                ctx.stroke();
-
-                // Bottom-left bracket
-                ctx.beginPath();
-                ctx.moveTo(px - bOff, py + bOff - 6);
-                ctx.lineTo(px - bOff, py + bOff);
-                ctx.lineTo(px - bOff + 6, py + bOff);
-                ctx.stroke();
-
-                // Bottom-right bracket
-                ctx.beginPath();
-                ctx.moveTo(px + bOff - 6, py + bOff);
-                ctx.lineTo(px + bOff, py + bOff);
-                ctx.lineTo(px + bOff, py + bOff - 6);
-                ctx.stroke();
-
-                // Data callout box
-                const boxX = px + 25;
-                const boxY = py - 50;
-                const boxW = 95;
-                const boxH = det.speed_kph ? 52 : 32;
-
-                // Line from target to box
-                ctx.strokeStyle = colors.dataBorder;
-                ctx.lineWidth = 1;
-                ctx.setLineDash([2, 2]);
-                ctx.beginPath();
-                ctx.moveTo(px + 15, py - 10);
-                ctx.lineTo(boxX, boxY + boxH / 2);
-                ctx.stroke();
-                ctx.setLineDash([]);
-
-                // Box background
-                ctx.fillStyle = colors.dataBox;
-                ctx.fillRect(boxX, boxY, boxW, boxH);
-
-                // Box border
-                ctx.strokeStyle = colors.dataBorder;
-                ctx.lineWidth = 1;
-                ctx.strokeRect(boxX, boxY, boxW, boxH);
-
-                // Corner accents
-                ctx.strokeStyle = colors.text;
-                ctx.lineWidth = 2;
-                const cornerLen = 5;
-
-                // Top-left
-                ctx.beginPath();
-                ctx.moveTo(boxX, boxY + cornerLen);
-                ctx.lineTo(boxX, boxY);
-                ctx.lineTo(boxX + cornerLen, boxY);
-                ctx.stroke();
-
-                // Top-right
-                ctx.beginPath();
-                ctx.moveTo(boxX + boxW - cornerLen, boxY);
-                ctx.lineTo(boxX + boxW, boxY);
-                ctx.lineTo(boxX + boxW, boxY + cornerLen);
-                ctx.stroke();
-
-                // Data text
-                ctx.font = "bold 10px 'Courier New', monospace";
-                ctx.fillStyle = colors.text;
-                ctx.textAlign = "left";
-
-                // Range
-                ctx.fillText(`RNG: ${Math.round(dist)}m`, boxX + 6, boxY + 14);
-
-                // Bearing
-                const bearingDeg = Math.round((angle + Math.PI / 2) * 180 / Math.PI);
-                ctx.fillText(`BRG: ${bearingDeg.toString().padStart(3, '0')}°`, boxX + 6, boxY + 28);
-
-                // Speed (if available)
-                if (det.speed_kph) {
-                    ctx.fillStyle = colors.neutral;
-                    ctx.fillText(`SPD: ${det.speed_kph.toFixed(0)} kph`, boxX + 6, boxY + 42);
-                }
-
-                // Trail rendering for selected target
-                if (det.history && det.history.length > 0 && det.gpt_distance_m) {
-                    const currH = det.bbox.h;
-                    const currDist = det.gpt_distance_m;
-
-                    ctx.save();
-                    const available = det.history.length;
-                    const startIdx = Math.max(0, available - maxHist);
-                    const subset = det.history.slice(startIdx);
-
-                    let points = [];
-                    subset.forEach((hBox) => {
-                        let hH, hX;
-                        if (hBox[0] <= 2.0 && hBox[2] <= 2.0) {
-                            hH = hBox[3] - hBox[1];
-                            hX = (hBox[0] + hBox[2]) / 2;
-                        } else {
-                            const fw = state.frame.w || 1280;
-                            const fh = state.frame.h || 720;
-                            hH = (hBox[3] - hBox[1]) / fh;
-                            hX = ((hBox[0] + hBox[2]) / 2) / fw;
-                        }
-                        if (hH <= 0.001) return;
-
-                        let distHist = currDist * (det.bbox.h / hH);
-                        const rPxHist = (clamp(distHist, 0, maxRangeM) / maxRangeM) * R;
-                        const txHist = hX - 0.5;
-                        const angleHist = (-Math.PI / 2) + (txHist * fovRad);
-                        const pxHist = cx + Math.cos(angleHist) * rPxHist;
-                        const pyHist = cy + Math.sin(angleHist) * rPxHist;
-                        points.push({ x: pxHist, y: pyHist });
-                    });
-
-                    points.push({ x: px, y: py });
-
-                    ctx.lineWidth = 1.5;
-                    for (let i = 0; i < points.length - 1; i++) {
-                        const p1 = points[i];
-                        const p2 = points[i + 1];
-                        const age = points.length - 1 - i;
-                        const alpha = Math.max(0, 1.0 - (age / (maxHist + 1)));
-
-                        ctx.beginPath();
-                        ctx.moveTo(p1.x, p1.y);
-                        ctx.lineTo(p2.x, p2.y);
-                        ctx.strokeStyle = threatColor;
-                        ctx.globalAlpha = alpha * 0.6;
-                        ctx.stroke();
-                    }
-                    ctx.globalAlpha = 1;
-                    ctx.restore();
-                }
-
-                // Predicted path
-                if (det.predicted_path && maxFut > 0) {
-                    ctx.save();
-                    const futSubset = det.predicted_path.slice(0, maxFut);
-
-                    if (futSubset.length > 0) {
-                        const currDist = det.gpt_distance_m || (det.depth_est_m || 2000);
-                        const fw = state.frame.w || 1280;
-                        const fh = state.frame.h || 720;
-
-                        let predPoints = [{ x: px, y: py }];
-
-                        futSubset.forEach((pt) => {
-                            const pX = pt[0] <= 2.0 ? pt[0] : (pt[0] / fw);
-                            const pY = pt[0] <= 2.0 ? pt[1] : (pt[1] / fh);
-                            const txP = pX - 0.5;
-                            const angP = (-Math.PI / 2) + (txP * fovRad);
-                            const cY = (det.bbox.y <= 2.0) ? (det.bbox.y + det.bbox.h / 2) : ((det.bbox.y + det.bbox.h / 2) / fh);
-                            let distP = currDist * (cY / Math.max(0.01, pY));
-                            const rPxP = (clamp(distP, 0, maxRangeM) / maxRangeM) * R;
-                            const pxP = cx + Math.cos(angP) * rPxP;
-                            const pyP = cy + Math.sin(angP) * rPxP;
-                            predPoints.push({ x: pxP, y: pyP });
-                        });
-
-                        ctx.lineWidth = 1.5;
-                        ctx.setLineDash([4, 4]);
-
-                        for (let i = 0; i < predPoints.length - 1; i++) {
-                            const p1 = predPoints[i];
-                            const p2 = predPoints[i + 1];
-                            const alpha = Math.max(0, 1.0 - (i / maxFut));
-
-                            ctx.beginPath();
-                            ctx.moveTo(p1.x, p1.y);
-                            ctx.lineTo(p2.x, p2.y);
-                            ctx.strokeStyle = threatColor;
-                            ctx.globalAlpha = alpha * 0.8;
-                            ctx.stroke();
-                        }
-                        ctx.setLineDash([]);
-                        ctx.globalAlpha = 1;
-                    }
-                    ctx.restore();
-                }
-            }
-        });
-    }
-
-    // ===========================================
-    // 8. STATUS OVERLAY - Top corners
-    // ===========================================
-    ctx.font = "bold 9px 'Courier New', monospace";
-    ctx.fillStyle = colors.textDim;
-    ctx.textAlign = "left";
-    ctx.textBaseline = "top";
-
-    // Top left - Mode
-    ctx.fillText(isStatic ? "SNAPSHOT" : "TGT ACQUISITION", 8, 8);
-
-    // Track count
-    const trackCount = source ? source.length : 0;
-    ctx.fillStyle = trackCount > 0 ? colors.text : colors.textDim;
-    ctx.fillText(`TRACKS: ${trackCount}`, 8, 22);
-
-    // Top right - Range setting
-    ctx.textAlign = "right";
-    ctx.fillStyle = colors.textDim;
-    ctx.fillText(`MAX RNG: ${maxRangeM}m`, w - 8, 8);
-
-    // Time
-    const timeStr = new Date().toLocaleTimeString('en-US', { hour12: false });
-    ctx.fillText(timeStr, w - 8, 22);
-
-    // Bottom center - FOV indicator
-    ctx.textAlign = "center";
-    ctx.fillStyle = colors.textDim;
-    ctx.fillText("FOV: 60°", cx, h - 12);
-};
-
-// Aliases for compatibility
-APP.ui.radar.renderFrameRadar = function () {
-    const { state } = APP.core;
-
-    // Only show tracks after first frame is processed
-    if (!state.firstFrameReady) {
-        APP.ui.radar.render("frameRadar", [], { static: true });
-        return;
-    }
-
-    // In demo mode, use demo data for first frame (time=0) to match video radar initial state
-    let trackSource = state.detections;
-    if (APP.core.demo.active && APP.core.demo.data) {
-        const demoTracks = APP.core.demo.getFrameData(0); // Get frame 0 data
-        if (demoTracks && demoTracks.length > 0) {
-            trackSource = demoTracks;
-        }
-    }
-
-    // First frame radar is static - no sweep animation
-    APP.ui.radar.render("frameRadar", trackSource, { static: true });
-};
-
-APP.ui.radar.renderLiveRadar = function () {
-    const { state } = APP.core;
-
-    // Only show tracks after Engage has been clicked (tracker running)
-    if (!state.tracker.running) {
-        APP.ui.radar.render("radarCanvas", [], { static: false });
-        return;
-    }
-
-    // Live radar has sweep animation
-    APP.ui.radar.render("radarCanvas", state.tracker.tracks, { static: false });
-};

frontend/js/ui/trade.js

@@ -1,291 +0,0 @@
-// Trade Space Visualization Module
-APP.ui.trade = {};
-
-APP.ui.trade.populateTradeTarget = function () {
-    const { state } = APP.core;
-    const { $ } = APP.core.utils;
-    const tradeTarget = $("#tradeTarget");
-
-    if (!tradeTarget) return;
-
-    const sel = tradeTarget.value;
-    tradeTarget.innerHTML = "";
-
-    const ids = state.detections.map(d => d.id);
-    if (!ids.length) {
-        const opt = document.createElement("option");
-        opt.value = "";
-        opt.textContent = "No targets";
-        tradeTarget.appendChild(opt);
-        return;
-    }
-
-    ids.forEach(id => {
-        const opt = document.createElement("option");
-        opt.value = id;
-        opt.textContent = id;
-        tradeTarget.appendChild(opt);
-    });
-
-    if (sel && ids.includes(sel)) tradeTarget.value = sel;
-    else tradeTarget.value = state.selectedId || ids[0];
-};
-
-APP.ui.trade.renderTrade = function () {
-    const { state } = APP.core;
-    const { $, clamp } = APP.core.utils;
-    const { maxPowerAtTarget, requiredDwell, pkillFromMargin } = APP.core.hel;
-
-    const tradeCanvas = $("#tradeCanvas");
-    const tradeTarget = $("#tradeTarget");
-    const rMin = $("#rMin");
-    const rMax = $("#rMax");
-    const showPk = $("#showPk");
-
-    if (!tradeCanvas) return;
-
-    const ctx = tradeCanvas.getContext("2d");
-    const W = tradeCanvas.width, H = tradeCanvas.height;
-    ctx.clearRect(0, 0, W, H);
-
-    // Background
-    ctx.fillStyle = "rgba(0,0,0,.32)";
-    ctx.fillRect(0, 0, W, H);
-
-    if (!state.detections.length) {
-        ctx.fillStyle = "rgba(255,255,255,.75)";
-        ctx.font = "14px " + getComputedStyle(document.body).fontFamily;
-        ctx.fillText("Run Reason to populate trade-space curves.", 18, 34);
-        return;
-    }
-
-    const id = (tradeTarget ? tradeTarget.value : null) || state.selectedId || state.detections[0].id;
-    const d = state.detections.find(x => x.id === id) || state.detections[0];
-
-    const r0 = Math.max(50, rMin ? +rMin.value : 200);
-    const r1 = Math.max(r0 + 50, rMax ? +rMax.value : 6000);
-
-    // Margins
-    const padL = 64, padR = 18, padT = 18, padB = 52;
-    const plotW = W - padL - padR;
-    const plotH = H - padT - padB;
-
-    // Compute sweep
-    const N = 120;
-    const xs = [];
-    let maxY = 0;
-    let minY = Infinity;
-
-    for (let i = 0; i <= N; i++) {
-        const r = r0 + (r1 - r0) * (i / N);
-        const mp = maxPowerAtTarget(r).Ptar;
-        const reqP = d.reqP_kW || 40;
-        const reqD = requiredDwell(r, reqP, mp, d.baseDwell_s || 5);
-
-        xs.push({ r, mp, reqP, reqD });
-        maxY = Math.max(maxY, mp, reqP);
-        minY = Math.min(minY, mp, reqP);
-    }
-
-    maxY = Math.max(maxY, 20);
-    minY = Math.max(0, minY - 10);
-
-    // Axes
-    ctx.strokeStyle = "rgba(255,255,255,.14)";
-    ctx.lineWidth = 1;
-    ctx.beginPath();
-    ctx.moveTo(padL, padT);
-    ctx.lineTo(padL, padT + plotH);
-    ctx.lineTo(padL + plotW, padT + plotH);
-    ctx.stroke();
-
-    // Grid lines
-    ctx.strokeStyle = "rgba(255,255,255,.07)";
-    for (let i = 1; i <= 5; i++) {
-        const y = padT + plotH * (i / 5);
-        ctx.beginPath(); ctx.moveTo(padL, y); ctx.lineTo(padL + plotW, y); ctx.stroke();
-    }
-    for (let i = 1; i <= 6; i++) {
-        const x = padL + plotW * (i / 6);
-        ctx.beginPath(); ctx.moveTo(x, padT); ctx.lineTo(x, padT + plotH); ctx.stroke();
-    }
-
-    // Helpers
-    const xMap = (r) => padL + (r - r0) / (r1 - r0) * plotW;
-    const yMap = (p) => padT + (1 - (p - minY) / (maxY - minY)) * plotH;
-
-    // Curve: max power at target
-    ctx.strokeStyle = "rgba(34,211,238,.95)";
-    ctx.lineWidth = 2.5;
-    ctx.beginPath();
-    xs.forEach((pt, i) => {
-        const x = xMap(pt.r);
-        const y = yMap(pt.mp);
-        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    });
-    ctx.stroke();
-
-    // Curve: required power
-    ctx.strokeStyle = "rgba(239,68,68,.90)";
-    ctx.lineWidth = 2.5;
-    ctx.beginPath();
-    xs.forEach((pt, i) => {
-        const x = xMap(pt.r);
-        const y = yMap(pt.reqP);
-        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    });
-    ctx.stroke();
-
-    // Annotate margin zones
-    ctx.fillStyle = "rgba(34,197,94,.08)";
-    ctx.beginPath();
-    xs.forEach((pt, i) => {
-        const x = xMap(pt.r);
-        const y = yMap(Math.max(pt.reqP, pt.mp));
-        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    });
-    for (let i = xs.length - 1; i >= 0; i--) {
-        const x = xMap(xs[i].r);
-        const y = yMap(Math.min(xs[i].reqP, xs[i].mp));
-        ctx.lineTo(x, y);
-    }
-    ctx.closePath();
-    ctx.fill();
-
-    // Second axis for dwell (scaled)
-    const dwellMax = Math.max(...xs.map(p => p.reqD));
-    const yMapD = (dwell) => padT + (1 - (dwell / Math.max(1e-6, dwellMax))) * plotH;
-
-    ctx.strokeStyle = "rgba(124,58,237,.85)";
-    ctx.lineWidth = 2.2;
-    ctx.beginPath();
-    xs.forEach((pt, i) => {
-        const x = xMap(pt.r);
-        const y = yMapD(pt.reqD);
-        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    });
-    ctx.stroke();
-
-    // Optional pkill band
-    if (showPk && showPk.value === "on") {
-        ctx.fillStyle = "rgba(245,158,11,.08)";
-        ctx.beginPath();
-        xs.forEach((pt, i) => {
-            const x = xMap(pt.r);
-            const mp = pt.mp;
-            const margin = mp - pt.reqP;
-            const pk = pkillFromMargin(margin, d.baseDwell_s || 5, pt.reqD);
-            const y = padT + plotH * (1 - pk);
-            if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-        });
-        ctx.lineTo(padL + plotW, padT + plotH);
-        ctx.lineTo(padL, padT + plotH);
-        ctx.closePath();
-        ctx.fill();
-    }
-
-    // Labels
-    ctx.fillStyle = "rgba(255,255,255,.84)";
-    ctx.font = "bold 14px " + getComputedStyle(document.body).fontFamily;
-    ctx.fillText(`Target: ${id} (${d.label})`, padL, 16);
-
-    ctx.fillStyle = "rgba(34,211,238,.95)";
-    ctx.fillText("Max P@Target (kW)", padL + 10, padT + plotH + 30);
-
-    ctx.fillStyle = "rgba(239,68,68,.92)";
-    ctx.fillText("Required P@Target (kW)", padL + 190, padT + plotH + 30);
-
-    ctx.fillStyle = "rgba(124,58,237,.90)";
-    ctx.fillText(`Required Dwell (s, scaled)`, padL + 420, padT + plotH + 30);
-
-    ctx.fillStyle = "rgba(255,255,255,.55)";
-    ctx.font = "11px " + getComputedStyle(document.body).fontFamily;
-    ctx.fillText(`Range (m)`, padL + plotW - 64, padT + plotH + 46);
-
-    // Axis ticks
-    ctx.fillStyle = "rgba(255,255,255,.55)";
-    ctx.font = "11px " + getComputedStyle(document.body).fontFamily;
-
-    for (let i = 0; i <= 5; i++) {
-        const p = minY + (maxY - minY) * (1 - i / 5);
-        const y = padT + plotH * (i / 5);
-        ctx.fillText(p.toFixed(0), 12, y + 4);
-    }
-
-    for (let i = 0; i <= 6; i++) {
-        const r = r0 + (r1 - r0) * (i / 6);
-        const x = padL + plotW * (i / 6);
-        ctx.fillText(r.toFixed(0), x - 14, padT + plotH + 18);
-    }
-
-    // Marker at baseline range
-    const rangeBase = $("#rangeBase");
-    const baseR = d.baseRange_m || (rangeBase ? +rangeBase.value : 1500);
-    const xb = xMap(clamp(baseR, r0, r1));
-    ctx.strokeStyle = "rgba(255,255,255,.28)";
-    ctx.setLineDash([6, 6]);
-    ctx.beginPath();
-    ctx.moveTo(xb, padT);
-    ctx.lineTo(xb, padT + plotH);
-    ctx.stroke();
-    ctx.setLineDash([]);
-};
-
-APP.ui.trade.updateHeadlines = function (sys, bestTarget) {
-    const { $ } = APP.core.utils;
-
-    const mMaxP = $("#m-maxp");
-    const mReqP = $("#m-reqp");
-    const mMargin = $("#m-margin");
-    const mMaxPSub = $("#m-maxp-sub");
-    const mPlanSub = $("#m-plan-sub");
-
-    if (!mMaxP) return;
-
-    if (mMaxP) mMaxP.textContent = sys.maxP ? `${sys.maxP} kW` : "—";
-    if (mReqP) mReqP.textContent = sys.reqP ? `${sys.reqP} kW` : "—";
-
-    if (mMargin) {
-        const margin = sys.margin || 0;
-        mMargin.textContent = `${margin > 0 ? "+" : ""}${margin} kW`;
-        mMargin.style.color = margin >= 0 ? "rgba(34,197,94,.95)" : "rgba(239,68,68,.95)";
-    }
-
-    if (mMaxPSub) mMaxPSub.textContent = "Calculated by external HEL engine";
-
-    if (bestTarget && bestTarget.pkill > 0) {
-        const mPlan = $("#m-plan");
-        if (mPlan) mPlan.textContent = `${bestTarget.id} → Engage`;
-        if (mPlanSub) mPlanSub.textContent = "Highest P(kill) target";
-    }
-};
-
-APP.ui.trade.snapshotTrade = function () {
-    const { state } = APP.core;
-    const { $, log } = APP.core.utils;
-    const { log: uiLog } = APP.ui.logging;
-
-    if (!state.detections.length) return;
-
-    const tradeTarget = $("#tradeTarget");
-    const helPower = $("#helPower");
-    const atmVis = $("#atmVis");
-    const atmCn2 = $("#atmCn2");
-    const aoQ = $("#aoQ");
-
-    const id = tradeTarget ? tradeTarget.value : state.selectedId;
-    const d = state.detections.find(x => x.id === id) || state.detections[0];
-
-    const snap = {
-        target: id,
-        helPower_kW: helPower ? +helPower.value : 0,
-        vis_km: atmVis ? +atmVis.value : 0,
-        cn2: atmCn2 ? +atmCn2.value : 0,
-        ao: aoQ ? +aoQ.value : 0,
-        baseRange_m: d.baseRange_m,
-        reqP_kW: d.reqP_kW,
-        baseDwell_s: d.baseDwell_s
-    };
-
-    uiLog("SNAPSHOT: " + JSON.stringify(snap), "t");
-};

inference.py

@@ -9,7 +9,7 @@ import collections
 import logging
 import time
 from threading import Event, RLock, Thread
-from queue import Queue, PriorityQueue, Full, Empty
+from queue import Queue, Full, Empty
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import cv2
@@ -20,8 +20,7 @@ from models.detectors.base import ObjectDetector
 from models.model_loader import load_detector, load_detector_on_device
 from models.segmenters.model_loader import load_segmenter, load_segmenter_on_device
 from models.depth_estimators.model_loader import load_depth_estimator, load_depth_estimator_on_device
-from models.depth_estimators.base import DepthEstimator
-from utils.video import extract_frames, write_video, VideoReader, VideoWriter, StreamingVideoWriter
+from utils.video import StreamingVideoWriter
 from utils.relevance import evaluate_relevance
 from utils.enrichment import run_enrichment
 from utils.schemas import AssessmentStatus
@@ -538,83 +537,6 @@ def infer_frame(
     ), detections
 
 
-def infer_batch(
-    frames: List[np.ndarray],
-    frame_indices: List[int],
-    queries: Sequence[str],
-    detector_instance: ObjectDetector,
-    depth_estimator_instance: Optional[DepthEstimator] = None,
-    depth_scale: float = 1.0,
-    depth_frame_stride: int = 3,
-) -> List[Tuple[int, np.ndarray, List[Dict[str, Any]]]]:
-    # Batch detection
-    text_queries = list(queries) or ["object"]
-    try:
-        if detector_instance.supports_batch:
-            with detector_instance.lock:
-                 det_results = detector_instance.predict_batch(frames, text_queries)
-        else:
-            # Fallback
-            with detector_instance.lock:
-                 det_results = [detector_instance.predict(f, text_queries) for f in frames]
-    except Exception:
-        logging.exception("Batch detection failed")
-        # Return empty for all
-        return [(idx, f, []) for idx, f in zip(frame_indices, frames)]
-
-    # Batch depth
-    depth_map_results = {} # frame_idx -> depth_map
-    depth_batch_inputs = []
-    depth_batch_indices = []
-
-    for idx, f in zip(frame_indices, frames):
-        if idx % depth_frame_stride == 0:
-            depth_batch_inputs.append(f)
-            depth_batch_indices.append(idx)
-    
-    if depth_estimator_instance and depth_batch_inputs:
-        try:
-             with depth_estimator_instance.lock:
-                 if depth_estimator_instance.supports_batch:
-                     d_results = depth_estimator_instance.predict_batch(depth_batch_inputs)
-                 else:
-                     d_results = [depth_estimator_instance.predict(f) for f in depth_batch_inputs]
-             
-             for idx, res in zip(depth_batch_indices, d_results):
-                 depth_map_results[idx] = res
-        except Exception:
-             logging.exception("Batch depth estimation failed")
-
-    # Post-process and merge
-    outputs = []
-    for i, (idx, frame, det_result) in enumerate(zip(frame_indices, frames, det_results)):
-        detections = _build_detection_records(
-            det_result.boxes, det_result.scores, det_result.labels, text_queries, det_result.label_names
-        )
-        
-        if idx in depth_map_results:
-             try:
-                 # existing _attach_depth_metrics expects detections and estimator name/instance
-                 # but we already computed depth. We need a helper or just modify logical flow.
-                 # Actually _attach_depth_metrics calls predict(). We want to skip predict.
-                 # Let's manually attach.
-                 d_res = depth_map_results[idx]
-                 # We need to manually invoke the attachment logic using the precomputed result.
-                 # Refactoring _attach_depth_metrics to accept result would be cleaner, but for now:
-                 # Copy-paste logic or use a trick.
-                 
-                 # Let's extract logic from _attach_depth_metrics essentially.
-                 # Wait, _attach_depth_metrics does the box checking.
-                 _attach_depth_from_result(detections, d_res, depth_scale)
-             except Exception:
-                 logging.warning("Failed to attach depth for frame %d", idx)
-
-        display_labels = [_build_display_label(d) for d in detections]
-        processed = draw_boxes(frame, det_result.boxes, label_names=display_labels)
-        outputs.append((idx, processed, detections))
-        
-    return outputs
-
 def _build_display_label(det):
     """Build display label with GPT distance if available."""
     label = det["label"]
@@ -713,46 +635,6 @@ def extract_first_frame(video_path: str) -> Tuple[np.ndarray, float, int, int]:
     return frame, fps, width, height
 
 
-def compute_depth_per_detection(
-    depth_map: np.ndarray,
-    detections: List[Dict],
-    depth_scale: float = 1.0
-) -> List[Dict]:
-    """Sample depth for each detection bbox, compute relative distances."""
-    depths = []
-    for det in detections:
-        x1, y1, x2, y2 = det["bbox"]
-        # Sample central 50% region for robustness (avoids edge artifacts)
-        cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
-        hw, hh = max(1, (x2 - x1) // 4), max(1, (y2 - y1) // 4)
-        y_start, y_end = max(0, cy - hh), min(depth_map.shape[0], cy + hh)
-        x_start, x_end = max(0, cx - hw), min(depth_map.shape[1], cx + hw)
-        region = depth_map[y_start:y_end, x_start:x_end]
-
-        valid = region[np.isfinite(region)]
-        if len(valid) >= 10:
-            det["depth_est_m"] = float(np.median(valid)) * depth_scale
-            det["depth_valid"] = True
-            depths.append(det["depth_est_m"])
-        else:
-            det["depth_est_m"] = None
-            det["depth_valid"] = False
-            det["depth_rel"] = None
-
-    # Per-frame relative normalization
-    if depths:
-        min_d, max_d = min(depths), max(depths)
-        span = max_d - min_d + 1e-6
-        for det in detections:
-            if det.get("depth_valid"):
-                det["depth_rel"] = (det["depth_est_m"] - min_d) / span
-    elif len(detections) == 1 and detections[0].get("depth_valid"):
-        # Single detection: assign neutral relative distance
-        detections[0]["depth_rel"] = 0.5
-
-    return detections
-
-
 def process_first_frame(
     video_path: str,
     queries: List[str],
@@ -1319,239 +1201,6 @@ def run_inference(
 
     logging.info("Inference complete. Output: %s", output_video_path)
     return output_video_path, sorted_detections
-
-
-
-def run_segmentation(
-    input_video_path: str,
-    output_video_path: str,
-    queries: List[str],
-    max_frames: Optional[int] = None,
-    segmenter_name: Optional[str] = None,
-    job_id: Optional[str] = None,
-    stream_queue: Optional[Queue] = None,
-) -> str:
-    # 1. Setup Reader
-    try:
-        reader = AsyncVideoReader(input_video_path)
-    except ValueError:
-        logging.exception("Failed to open video at %s", input_video_path)
-        raise
-
-    fps = reader.fps
-    width = reader.width
-    height = reader.height
-    total_frames = reader.total_frames
-    
-    if max_frames is not None:
-        total_frames = min(total_frames, max_frames)
-        
-    active_segmenter = segmenter_name or "gsam2_large"
-    logging.info("Using segmenter: %s with queries: %s", active_segmenter, queries)
-
-    # 2. Load Segmenters (Parallel)
-    
-    # DEBUG: Log current state
-    logging.info(f"[DEBUG] Segmentation PID: {os.getpid()}")
-    logging.info(f"[DEBUG] CUDA_VISIBLE_DEVICES before clear: {os.environ.get('CUDA_VISIBLE_DEVICES')}")
-    
-    
-    # if "CUDA_VISIBLE_DEVICES" in os.environ:
-    #      logging.info("[DEBUG] Deleting CUDA_VISIBLE_DEVICES from env (segmentation)")
-    #      del os.environ["CUDA_VISIBLE_DEVICES"]
-
-    num_gpus = torch.cuda.device_count()
-    logging.info(f"[DEBUG] num_gpus: {num_gpus}")
-    segmenters = []
-
-    if num_gpus > 0:
-        logging.info("Detected %d GPUs. Loading segmenters...", num_gpus)
-        def load_seg(gpu_id: int):
-            device_str = f"cuda:{gpu_id}"
-            seg = load_segmenter_on_device(active_segmenter, device_str)
-            seg.lock = RLock()
-            return (gpu_id, seg)
-            
-        with ThreadPoolExecutor(max_workers=num_gpus) as loader:
-            futures = [loader.submit(load_seg, i) for i in range(num_gpus)]
-            results = [f.result() for f in futures]
-            results.sort(key=lambda x: x[0])
-            segmenters = [r[1] for r in results]
-    else:
-        seg = load_segmenter(active_segmenter)
-        seg.lock = RLock()
-        segmenters.append(seg)
-
-    # 3. Processing
-    queue_in = Queue(maxsize=16)
-    queue_out = Queue(maxsize=max(32, len(segmenters)*4))
-    
-    writer_finished = False # Robustness
-    
-    def worker_seg(gpu_idx: int):
-        seg = segmenters[gpu_idx]
-        batch_size = seg.max_batch_size if seg.supports_batch else 1
-        batch_accum = []
-
-        def flush_batch():
-            if not batch_accum: return
-            indices = [i for i, _ in batch_accum]
-            frames = [f for _, f in batch_accum]
-            
-            try:
-                # 1. Inference
-                if seg.supports_batch:
-                    with seg.lock:
-                         results = seg.predict_batch(frames, queries)
-                else:
-                    with seg.lock:
-                         results = [seg.predict(f, queries) for f in frames]
-                
-                # 2. Post-process loop
-                for idx, frm, res in zip(indices, frames, results):
-                    labels = queries or []
-                    if len(labels) == 1:
-                        masks = res.masks if res.masks is not None else []
-                        labels = [labels[0] for _ in range(len(masks))]
-                    processed = draw_masks(frm, res.masks, labels=labels)
-
-                    while True:
-                        try:
-                            queue_out.put((idx, processed), timeout=1.0)
-                            break
-                        except Full:
-                             if writer_finished:
-                                 raise RuntimeError("Writer thread died")
-                             if job_id: _check_cancellation(job_id)
-
-            except Exception as e:
-                logging.error("Batch seg failed: %s", e)
-                # Fallback: Emit failed frames to prevent writer stall
-                for idx, frm in batch_accum:
-                     while True:
-                        try:
-                            # Return original frame without mask
-                            queue_out.put((idx, frm), timeout=1.0)
-                            break
-                        except Full:
-                             if writer_finished: break
-                             if job_id: _check_cancellation(job_id)
-            batch_accum.clear()
-
-        while True:
-            item = queue_in.get()
-            try:
-                if item is None:
-                    flush_batch()
-                    break
-                
-                idx, frame = item
-                batch_accum.append(item)
-                if idx % 30 == 0:
-                     logging.debug("Seg frame %d (GPU %d)", idx, gpu_idx)
-
-                if len(batch_accum) >= batch_size:
-                    flush_batch()
-            finally:
-                queue_in.task_done()
-
-    workers = []
-    for i in range(len(segmenters)):
-        t = Thread(target=worker_seg, args=(i,), daemon=True)
-        t.start()
-        workers.append(t)
-
-    # Writer
-    # writer_finished moved up for closure scope match
-
-
-    # Writer
-    # Writer
-    # writer_finished defined earlier
-
-    
-    def writer_loop():
-        nonlocal writer_finished
-        next_idx = 0
-        buffer = {}
-        
-        try:
-            with StreamingVideoWriter(output_video_path, fps, width, height) as writer:
-                while next_idx < total_frames:
-                    try:
-                        while next_idx not in buffer:
-                            if len(buffer) > 128:
-                                logging.warning("Writer reorder buffer too large (%d), applying backpressure (waiting for frame %d)...", len(buffer), next_idx)
-                                time.sleep(0.05)
-
-                            idx, frm = queue_out.get(timeout=1.0)
-                            buffer[idx] = frm
-
-                        frm = buffer.pop(next_idx)
-                        writer.write(frm)
-
-                        if stream_queue:
-                            try:
-                                stream_queue.put_nowait(frm)
-                            except:
-                                pass
-
-                        next_idx += 1
-                    except Exception:
-                         if job_id and _check_cancellation(job_id): pass
-                         if not any(w.is_alive() for w in workers) and queue_out.empty():
-                             break
-                         continue
-        finally:
-            writer_finished = True
-
-    w_thread = Thread(target=writer_loop, daemon=True)
-    w_thread.start()
-
-    # Feeder
-    try:
-        reader_iter = iter(reader)
-        frames_fed = 0
-        while True:
-            _check_cancellation(job_id)
-            if max_frames is not None and frames_fed >= max_frames:
-                break
-                
-            try:
-                frame = next(reader_iter)
-            except StopIteration:
-                break
-                
-            queue_in.put((frames_fed, frame))
-            frames_fed += 1
-            
-        # Update total_frames to actual count
-        if frames_fed != total_frames:
-             logging.info("Updating total_frames from %d to %d (actual fed)", total_frames, frames_fed)
-             total_frames = frames_fed
-            
-        for _ in workers:
-            try: queue_in.put(None, timeout=5.0)
-            except Full: pass
-            
-        queue_in.join()
-        
-    except Exception:
-        logging.exception("Segmentation loop failed")
-        for _ in workers: 
-            try: queue_in.put_nowait(None) 
-            except Full: pass
-        raise
-    finally:
-        reader.close()
-        
-    w_thread.join()
-    
-    logging.info("Segmented video written to: %s", output_video_path)
-    return output_video_path
-
-
-
 def _gsam2_render_frame(
     frame_dir: str,
     frame_names: List[str],
@@ -1566,8 +1215,6 @@ def _gsam2_render_frame(
     When *masks_only* is True, skip box rendering so the writer thread can
     draw boxes later with enriched (GPT) labels.
     """
-    from models.segmenters.grounded_sam2 import ObjectInfo
-
     frame_path = os.path.join(frame_dir, frame_names[frame_idx])
     frame = cv2.imread(frame_path)
     if frame is None:
@@ -1577,7 +1224,6 @@ def _gsam2_render_frame(
         return frame
 
     masks_list: List[np.ndarray] = []
-    mask_labels: List[str] = []
     boxes_list: List[List[int]] = []
     box_labels: List[str] = []
 
@@ -1596,7 +1242,6 @@ def _gsam2_render_frame(
                     interpolation=cv2.INTER_NEAREST,
                 ).astype(bool)
             masks_list.append(mask_np)
-            mask_labels.append(label)
 
         has_box = not (
             obj_info.x1 == 0 and obj_info.y1 == 0
@@ -2489,256 +2134,6 @@ def run_grounded_sam2_tracking(
             logging.warning("Failed to clean up temp frame dir: %s", frame_dir)
 
 
-def run_depth_inference(
-    input_video_path: str,
-    output_video_path: str,
-    detections: Optional[List[List[Dict[str, Any]]]] = None,
-    max_frames: Optional[int] = None,
-    depth_estimator_name: str = "depth",
-    first_frame_depth_path: Optional[str] = None,
-    job_id: Optional[str] = None,
-    stream_queue: Optional[Queue] = None,
-) -> str:
-    # 1. Setup Reader
-    try:
-        reader = AsyncVideoReader(input_video_path)
-    except ValueError:
-        logging.exception("Failed to open video at %s", input_video_path)
-        raise
-
-    fps = reader.fps
-    width = reader.width
-    height = reader.height
-    total_frames = reader.total_frames
-    
-    if max_frames is not None:
-        total_frames = min(total_frames, max_frames)
-        
-    logging.info("Using depth estimator: %s", depth_estimator_name)
-
-    # 2. Load Estimators (Parallel)
-    num_gpus = torch.cuda.device_count()
-    estimators = []
-    
-    # if "CUDA_VISIBLE_DEVICES" in os.environ:
-    #      del os.environ["CUDA_VISIBLE_DEVICES"]
-
-    if num_gpus > 0:
-        logging.info("Detected %d GPUs. Loading depth estimators...", num_gpus)
-        def load_est(gpu_id: int):
-            device_str = f"cuda:{gpu_id}"
-            est = load_depth_estimator_on_device(depth_estimator_name, device_str)
-            est.lock = RLock()
-            return (gpu_id, est)
-            
-        with ThreadPoolExecutor(max_workers=num_gpus) as loader:
-            futures = [loader.submit(load_est, i) for i in range(num_gpus)]
-            results = [f.result() for f in futures]
-            results.sort(key=lambda x: x[0])
-            estimators = [r[1] for r in results]
-    else:
-        est = load_depth_estimator(depth_estimator_name)
-        est.lock = RLock()
-        estimators.append(est)
-
-    # 3. Incremental Depth Stats (replaces expensive pre-scan)
-    depth_stats = IncrementalDepthStats(warmup_frames=30)
-    
-    # 4. Phase 2: Streaming Inference
-    logging.info("Starting Phase 2: Streaming...")
-    
-    queue_in = Queue(maxsize=16)
-    queue_out_max = max(32, (len(estimators) if estimators else 1) * 4)
-    queue_out = Queue(maxsize=queue_out_max)
-    
-    writer_finished = False
-    
-    def worker_depth(gpu_idx: int):
-        est = estimators[gpu_idx]
-        batch_size = est.max_batch_size if est.supports_batch else 1
-        batch_accum = []
-
-        def flush_batch():
-            if not batch_accum: return
-            indices = [i for i, _ in batch_accum]
-            frames = [f for _, f in batch_accum]
-
-            try:
-                # 1. Inference
-                if est.supports_batch:
-                    with est.lock:
-                         results = est.predict_batch(frames)
-                else:
-                    with est.lock:
-                         results = [est.predict(f) for f in frames]
-                
-                # Update incremental depth stats
-                for res in results:
-                    if res and res.depth_map is not None:
-                        depth_stats.update(res.depth_map)
-
-                # 2. Post-process loop
-                for idx, frm, res in zip(indices, frames, results):
-                    depth_map = res.depth_map
-                    ds_min, ds_max = depth_stats.range
-                    colored = colorize_depth_map(depth_map, ds_min, ds_max)
-                    
-                    # Overlay Detections
-                    if detections and idx < len(detections):
-                         frame_dets = detections[idx]
-                         if frame_dets:
-                             boxes = []
-                             labels = []  
-                             for d in frame_dets:
-                                 boxes.append(d.get("bbox"))
-                                 lbl = d.get("label", "obj")
-                                 if d.get("gpt_distance_m"):
-                                     lbl = f"{lbl} {int(d['gpt_distance_m'])}m"
-                                 labels.append(lbl)
-                             colored = draw_boxes(colored, boxes=boxes, label_names=labels)
-                    
-                    while True:
-                        try:
-                            queue_out.put((idx, colored), timeout=1.0)
-                            break
-                        except Full:
-                             if writer_finished:
-                                 raise RuntimeError("Writer died")
-                             if job_id: _check_cancellation(job_id)
-
-            except Exception as e:
-                logging.error("Batch depth failed: %s", e)
-                # Fallback: Emit original frames (no depth map)
-                for idx, frm in batch_accum:
-                     while True:
-                        try:
-                            queue_out.put((idx, frm), timeout=1.0)
-                            break
-                        except Full:
-                             if writer_finished: break
-                             if job_id: _check_cancellation(job_id)
-            batch_accum.clear()
-
-        while True:
-            item = queue_in.get()
-            try:
-                if item is None:
-                    flush_batch()
-                    break
-                
-                idx, frame = item
-                batch_accum.append(item)
-                
-                if idx % 30 == 0:
-                     logging.info("Depth frame %d (GPU %d)", idx, gpu_idx)
-
-                if len(batch_accum) >= batch_size:
-                    flush_batch()
-            finally:
-                queue_in.task_done()
-            
-    # Workers
-    workers = []
-    for i in range(len(estimators)):
-        t = Thread(target=worker_depth, args=(i,), daemon=True)
-        t.start()
-        workers.append(t)
-        
-    # Writer
-    # Writer
-    # writer_finished defined earlier
-
-    first_frame_saved = False
-    
-    def writer_loop():
-        nonlocal writer_finished, first_frame_saved
-        next_idx = 0
-        buffer = {}
-        processed_frames_subset = [] # Keep first frame for saving if needed
-        
-        try:
-            with StreamingVideoWriter(output_video_path, fps, width, height) as writer:
-                while next_idx < total_frames:
-                    try:
-                        while next_idx not in buffer:
-                            if len(buffer) > 128:
-                                logging.warning("Writer reorder buffer too large (%d), applying backpressure (waiting for frame %d)...", len(buffer), next_idx)
-                                time.sleep(0.05)
-                            idx, frm = queue_out.get(timeout=1.0)
-                            buffer[idx] = frm
-
-                        frm = buffer.pop(next_idx)
-                        writer.write(frm)
-
-                        if stream_queue:
-                            try:
-                                stream_queue.put_nowait(frm)
-                            except:
-                                pass
-
-
-                        if first_frame_depth_path and not first_frame_saved and next_idx == 0:
-                            cv2.imwrite(first_frame_depth_path, frm)
-                            first_frame_saved = True
-
-                        next_idx += 1
-                        if next_idx % 30 == 0:
-                             logging.debug("Wrote depth frame %d/%d", next_idx, total_frames)
-                    except Exception:
-                         if job_id and _check_cancellation(job_id): pass
-                         if not any(w.is_alive() for w in workers) and queue_out.empty():
-                             break
-                         continue
-        finally:
-            writer_finished = True
-
-    w_thread = Thread(target=writer_loop, daemon=True)
-    w_thread.start()
-
-    # Feeder
-    try:
-        reader_iter = iter(reader)
-        frames_fed = 0
-        while True:
-            _check_cancellation(job_id)
-            if max_frames is not None and frames_fed >= max_frames:
-                break
-                
-            try:
-                frame = next(reader_iter)
-            except StopIteration:
-                break
-                
-            queue_in.put((frames_fed, frame))
-            frames_fed += 1
-        
-        # Update total_frames to actual count
-        if frames_fed != total_frames:
-             logging.info("Updating total_frames from %d to %d (actual fed)", total_frames, frames_fed)
-             total_frames = frames_fed
-
-        for _ in workers:
-            try: queue_in.put(None, timeout=5.0)
-            except Full: pass
-            
-        queue_in.join()
-        
-    except Exception:
-        logging.exception("Depth loop failed")
-        for _ in workers:
-             try: queue_in.put_nowait(None)
-             except Full: pass
-        raise
-        
-    finally:
-        reader.close()
-        
-    w_thread.join()
-    
-    return output_video_path
-
-
-
 def colorize_depth_map(
     depth_map: np.ndarray,
     global_min: float,

models/depth_estimators/base.py

@@ -1,4 +1,4 @@
-from typing import NamedTuple, Sequence, List
+from typing import NamedTuple, Sequence
 
 import numpy as np
 

models/detectors/drone_yolo.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from typing import List, Sequence
 
 import numpy as np

models/segmenters/base.py

@@ -1,4 +1,4 @@
-from typing import NamedTuple, Optional, Sequence, List
+from typing import NamedTuple, Optional, Sequence
 
 import numpy as np
 

utils/gpt_reasoning.py

@@ -1,11 +1,10 @@
-import os
 import re
 import json
 import base64
 import logging
 from typing import List, Dict, Any, Optional
-from utils.schemas import FrameThreatAnalysis, AssessmentStatus
-from utils.openai_client import chat_completion, extract_content, get_api_key, OpenAIAPIError
+from utils.schemas import AssessmentStatus
+from utils.openai_client import chat_completion, extract_content, get_api_key
 
 logger = logging.getLogger(__name__)
 

utils/profiler.py

@@ -9,7 +9,7 @@ import logging
 import statistics
 import time
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Sequence
+from typing import List, Optional, Sequence
 
 import cv2
 import numpy as np

utils/schemas.py

@@ -1,49 +1,5 @@
 from pydantic import BaseModel, Field
-from typing import List, Optional, Literal
-
-
-class DynamicFeature(BaseModel):
-    """A single domain-specific key-value observation chosen by the analyst."""
-    key: str = Field(..., description="Feature name (e.g., 'wake_description', 'deck_activity', 'camouflage').")
-    value: str = Field(..., description="Observed value for this feature.")
-
-
-class ThreatAssessment(BaseModel):
-    """
-    Universal tactical threat assessment for a detected object.
-    Works across NAVAL, GROUND, AERIAL, URBAN, and GENERIC domains.
-    10 predefined fields + up to 5 analyst-chosen dynamic features.
-    """
-    # 1. Classification
-    object_type: str = Field(..., description="Broad category (e.g., 'Warship', 'APC', 'Sedan', 'Rotary-wing Aircraft', 'Person').")
-    size: str = Field("Unknown", description="Relative size estimate (e.g., 'Large', 'Medium', 'Small', '~50m length').")
-
-    # 2. Capabilities & Weapons
-    visible_weapons: List[str] = Field(default_factory=list, description="Visible weaponry (e.g., 'Deck Gun', 'Turret-mounted MG', 'Rifle').")
-    weapon_readiness: str = Field("Unknown", description="State of visible weapons (e.g., 'Stowed/PEACE', 'Trained/Aiming', 'Firing/HOSTILE').")
-
-    # 3. Kinematics
-    motion_status: str = Field("Unknown", description="Movement status (e.g., 'Stationary', 'Moving Slow', 'Moving Fast', 'Hovering').")
-
-    # 4. Spatial / Geometry
-    range_estimate: str = Field("Unknown", description="Estimated range as free text (e.g., '~500m', '~2NM', '~1km').")
-    bearing: str = Field("Unknown", description="Relative bearing (e.g., '12 o\\'clock', 'NNE', '045°').")
-
-    # 5. Threat Assessment
-    threat_level: int = Field(..., ge=1, le=10, description="1-10 Threat Score (1=Benign, 10=Imminent Attack).")
-    threat_classification: Literal["Friendly", "Neutral", "Suspect", "Hostile"] = Field(..., description="Tactical classification.")
-    tactical_intent: str = Field(..., description="Inferred intent (e.g., 'Transit', 'Patrol', 'Attack Profile', 'Surveillance').")
-
-    # 6. Dynamic Features (analyst-chosen, domain-specific)
-    dynamic_features: List[DynamicFeature] = Field(
-        default_factory=list, max_length=5,
-        description="Up to 5 additional domain-specific observations chosen by the analyst."
-    )
-
-
-class FrameThreatAnalysis(BaseModel):
-    objects: dict[str, ThreatAssessment] = Field(..., description="Map of Object ID (e.g., 'T01') to its assessment.")
-
+from typing import List, Literal
 
 # --- Mission-Driven Abstractions ---
 
@@ -157,4 +113,3 @@ class AssessmentStatus:
     ERROR = "ERROR"
     NO_RESPONSE = "NO_RESPONSE"
     STALE = "STALE"
-

utils/tiling.py

@@ -1,7 +1,6 @@
 import numpy as np
 import torch
-import logging
-from typing import List, Tuple, Dict, Any, Optional
+from typing import List
 
 def get_slice_bboxes(
     image_height: int,

utils/video.py

@@ -54,29 +54,6 @@ def extract_frames_to_jpeg_dir(
     return frame_names, fps, width, height
 
 
-def extract_frames(video_path: str) -> Tuple[List[np.ndarray], float, int, int]:
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        raise ValueError("Unable to open video.")
-
-    fps = cap.get(cv2.CAP_PROP_FPS) or 0.0
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-    frames: List[np.ndarray] = []
-    success, frame = cap.read()
-    while success:
-        frames.append(frame)
-        success, frame = cap.read()
-
-    cap.release()
-
-    if not frames:
-        raise ValueError("Video decode produced zero frames.")
-
-    return frames, fps, width, height
-
-
 def _transcode_with_ffmpeg(src_path: str, dst_path: str) -> None:
     cmd = [
         "ffmpeg",
@@ -102,31 +79,6 @@ def _transcode_with_ffmpeg(src_path: str, dst_path: str) -> None:
         logging.info("ffmpeg success")
 
 
-def write_video(frames: List[np.ndarray], output_path: str, fps: float, width: int, height: int) -> None:
-    if not frames:
-        raise ValueError("No frames available for writing.")
-    temp_fd, temp_path = tempfile.mkstemp(prefix="raw_", suffix=".mp4")
-    os.close(temp_fd)
-    writer = cv2.VideoWriter(temp_path, cv2.VideoWriter_fourcc(*"mp4v"), fps or 1.0, (width, height))
-    if not writer.isOpened():
-        os.remove(temp_path)
-        raise ValueError("Failed to open VideoWriter.")
-
-    for frame in frames:
-        writer.write(frame)
-
-    writer.release()
-    try:
-        _transcode_with_ffmpeg(temp_path, output_path)
-        logging.debug("Transcoded video to H.264 for browser compatibility.")
-        os.remove(temp_path)
-    except FileNotFoundError:
-        logging.warning("ffmpeg not found; serving fallback MP4V output.")
-        shutil.move(temp_path, output_path)
-    except RuntimeError as exc:
-        logging.warning("ffmpeg transcode failed (%s); serving fallback MP4V output.", exc)
-        shutil.move(temp_path, output_path)
-
 class VideoReader:
     def __init__(self, video_path: str):
         self.video_path = video_path
@@ -163,94 +115,6 @@ class VideoReader:
         self.close()
 
 
-class AsyncVideoReader:
-    """
-    Async video reader that decodes frames in a background thread.
-    
-    This prevents GPU starvation on multi-GPU systems by prefetching frames
-    while the main thread is busy dispatching work to GPUs.
-    """
-    
-    def __init__(self, video_path: str, prefetch_size: int = 32):
-        """
-        Initialize async video reader.
-        
-        Args:
-            video_path: Path to video file
-            prefetch_size: Number of frames to prefetch (default 32)
-        """
-        from queue import Queue
-        from threading import Thread
-        
-        self.video_path = video_path
-        self.prefetch_size = prefetch_size
-        
-        # Open video to get metadata
-        self._cap = cv2.VideoCapture(video_path)
-        if not self._cap.isOpened():
-            raise ValueError(f"Unable to open video: {video_path}")
-        
-        self.fps = self._cap.get(cv2.CAP_PROP_FPS) or 30.0
-        self.width = int(self._cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        self.height = int(self._cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        self.total_frames = int(self._cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        
-        # Prefetch queue
-        self._queue: Queue = Queue(maxsize=prefetch_size)
-        self._error: Exception = None
-        self._finished = False
-        
-        # Start decoder thread
-        self._thread = Thread(target=self._decode_loop, daemon=True)
-        self._thread.start()
-    
-    def _decode_loop(self):
-        """Background thread that continuously decodes frames."""
-        try:
-            while True:
-                success, frame = self._cap.read()
-                if not success:
-                    break
-                self._queue.put(frame)  # Blocks when queue is full (backpressure)
-        except Exception as e:
-            self._error = e
-            logging.error(f"AsyncVideoReader decode error: {e}")
-        finally:
-            self._cap.release()
-            self._queue.put(None)  # Sentinel to signal end
-            self._finished = True
-    
-    def __iter__(self):
-        return self
-    
-    def __next__(self) -> np.ndarray:
-        if self._error:
-            raise self._error
-        
-        frame = self._queue.get()
-        if frame is None:
-            raise StopIteration
-        return frame
-    
-    def close(self):
-        """Stop the decoder thread and release resources."""
-        # Signal thread to stop by releasing cap (if not already done)
-        if self._cap.isOpened():
-            self._cap.release()
-        # Drain queue to unblock thread if it's waiting on put()
-        while not self._queue.empty():
-            try:
-                self._queue.get_nowait()
-            except:
-                break
-    
-    def __enter__(self):
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-
 class VideoWriter:
     def __init__(self, output_path: str, fps: float, width: int, height: int):
         self.output_path = output_path