frontend/js/core/tracker.js

APP.core.tracker = {};

APP.core.tracker.matchAndUpdateTracks = function (dets, dtSec) {
    const { state } = APP.core;
    const { CONFIG } = APP.core;
    const { normBBox, lerp, now, $ } = APP.core.utils;
    const { defaultAimpoint } = APP.core.physics;
    const { log } = APP.ui.logging;

    const videoEngage = $("#videoEngage");
    const rangeBase = $("#rangeBase"); // Fixed Selector

    if (!videoEngage) return;

    // IOU helper
    function iou(a, b) {
        const ax2 = a.x + a.w, ay2 = a.y + a.h;
        const bx2 = b.x + b.w, by2 = b.y + b.h;
        const ix1 = Math.max(a.x, b.x), iy1 = Math.max(a.y, b.y);
        const ix2 = Math.min(ax2, bx2), iy2 = Math.min(ay2, by2);
        const iw = Math.max(0, ix2 - ix1), ih = Math.max(0, iy2 - iy1);
        const inter = iw * ih;
        const ua = a.w * a.h + b.w * b.h - inter;
        return ua <= 0 ? 0 : inter / ua;
    }

    // Convert detections to bbox in video coordinates
    const w = videoEngage.videoWidth || state.frame.w;
    const h = videoEngage.videoHeight || state.frame.h;

    const detObjs = dets.map(d => ({
        bbox: normBBox(d.bbox, w, h),
        label: d.class,
        score: d.score,
        depth_rel: Number.isFinite(d.depth_rel) ? d.depth_rel : null,
        depth_est_m: d.depth_est_m,
        depth_valid: d.depth_valid
    }));

    // mark all tracks as unmatched
    const tracks = state.tracker.tracks;
    const used = new Set();

    for (const tr of tracks) {
        let best = null;
        let bestI = 0.0;
        let bestIdx = -1;
        for (let i = 0; i < detObjs.length; i++) {
            if (used.has(i)) continue;
            const IoU = iou(tr.bbox, detObjs[i].bbox);
            if (IoU > bestI) {
                bestI = IoU;
                best = detObjs[i];
                bestIdx = i;
            }
        }

        // Strict matching threshold
        if (best && bestI >= CONFIG.TRACK_MATCH_THRESHOLD) {
            used.add(bestIdx);

            // 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;

            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.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').
            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.score = best.score || tr.score;
            if (Number.isFinite(best.depth_rel)) {
                tr.depth_rel = best.depth_rel;
            }
            if (best.depth_valid) {
                // EMA Smoothing
                const newD = best.depth_est_m;
                if (tr.depth_est_m == null) tr.depth_est_m = newD;
                else tr.depth_est_m = tr.depth_est_m * 0.7 + newD * 0.3;
                tr.depth_valid = true;
            }
            tr.lastSeen = now();
        } else {
            // Decay velocity
            tr.vx *= 0.9;
            tr.vy *= 0.9;
        }
    }

    // Limit total tracks
    if (tracks.length < CONFIG.MAX_TRACKS) {
        for (let i = 0; i < detObjs.length; i++) {
            if (used.has(i)) continue;
            // create new track only if big enough
            const a = detObjs[i].bbox.w * detObjs[i].bbox.h;
            if (a < (w * h) * 0.0005) 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 ? +rangeBase.value : 1000,
                baseDwell_s: 5.5,
                reqP_kW: 42,
                depth_rel: detObjs[i].depth_rel,
                depth_est_m: detObjs[i].depth_est_m,
                depth_valid: detObjs[i].depth_valid,

                // GPT properties
                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
    const tNow = now();
    state.tracker.tracks = tracks.filter(tr => (tNow - tr.lastSeen) < CONFIG.TRACK_PRUNE_MS || tr.killed);
};

// Polling for backend tracks
APP.core.tracker.syncWithBackend = async function (frameIdx) {
    const { state } = APP.core;
    const { $ } = APP.core.utils;
    const jobId = state.hf.asyncJobId || state.hf.completedJobId;

    if (!jobId || !state.hf.baseUrl) return;

    try {
        const resp = await fetch(`${state.hf.baseUrl}/detect/tracks/${jobId}/${frameIdx}`);
        if (!resp.ok) return;

        const dets = await resp.json();
        if (!dets || !Array.isArray(dets)) return;

        // Transform backend format to frontend track format
        // Backend: { bbox: [x1, y1, x2, y2], label: "car", track_id: "T01", angle_deg: 90, ... }
        // Frontend: { id: "T01", bbox: {x,y,w,h}, label: "car", angle_deg: 90, ... }

        const videoEngage = $("#videoEngage");
        const w = videoEngage ? (videoEngage.videoWidth || state.frame.w) : state.frame.w;
        const h = videoEngage ? (videoEngage.videoHeight || state.frame.h) : state.frame.h;

        const newTracks = dets.map(d => {
            const x = d.bbox[0], y = d.bbox[1];
            const wBox = d.bbox[2] - d.bbox[0];
            const hBox = d.bbox[3] - d.bbox[1];

            // Normalize
            const nx = x / w;
            const ny = y / h;
            const nw = wBox / w;
            const nh = hBox / h;

            return {
                id: d.track_id || `T${Math.floor(Math.random() * 1000)}`, // Fallback
                label: d.label,
                bbox: { x: nx, y: ny, w: nw, h: nh },
                score: d.score,
                angle_deg: d.angle_deg,
                gpt_distance_m: d.gpt_distance_m,
                gpt_direction: d.gpt_direction,
                gpt_description: d.gpt_description,
                speed_kph: d.speed_kph,
                depth_est_m: d.depth_est_m,
                depth_rel: d.depth_rel,
                depth_valid: d.depth_valid,
                // Threat intelligence
                threat_level_score: d.threat_level_score || 0,
                threat_classification: d.threat_classification || "Unknown",
                weapon_readiness: d.weapon_readiness || "Unknown",
                // Mission relevance and assessment status
                mission_relevant: d.mission_relevant ?? null,
                relevance_reason: d.relevance_reason || null,
                assessment_status: d.assessment_status || APP.core.gptMapping.STATUS.UNASSESSED,
                assessment_frame_index: d.assessment_frame_index ?? null,
                // GPT raw data for feature table
                gpt_raw: d.gpt_raw || null,
                features: APP.core.gptMapping.buildFeatures(d.gpt_raw),
                // Keep UI state fields
                lastSeen: Date.now(),
                state: "TRACK"
            };
        });

        // Preserve GPT enrichment data that syncWithBackend would otherwise wipe
        const gptCache = state.hf.firstFrameDetections;
        if (gptCache && gptCache.length > 0) {
            const gptMap = {};
            for (const gd of gptCache) {
                const tid = gd.track_id || `T${String(gptCache.indexOf(gd) + 1).padStart(2, "0")}`;
                if (gd.gpt_raw) gptMap[tid] = gd;
            }
            for (const track of newTracks) {
                const cached = gptMap[track.id];
                if (!cached || track.gpt_raw) continue;
                const g = cached.gpt_raw;
                track.gpt_raw = g;
                track.assessment_status = cached.assessment_status || APP.core.gptMapping.STATUS.ASSESSED;
                track.threat_level_score = cached.threat_level_score || g.threat_level_score || 0;
                track.threat_classification = cached.threat_classification || g.threat_classification || "Unknown";
                track.weapon_readiness = cached.weapon_readiness || g.weapon_readiness || "Unknown";
                track.gpt_distance_m = cached.gpt_distance_m || null;
                track.gpt_direction = cached.gpt_direction || null;
                track.mission_relevant = cached.mission_relevant ?? track.mission_relevant;
                track.relevance_reason = cached.relevance_reason || track.relevance_reason;
                track.features = APP.core.gptMapping.buildFeatures(g);
            }
        }

        // Detect new objects before state update
        const oldIds = new Set(state.tracker.tracks.map(t => t.id));
        const brandNew = newTracks.filter(t => !oldIds.has(t.id));
        if (brandNew.length > 0) {
            state.tracker._newObjectDetected = true;
            APP.ui.logging.log(`New objects: ${brandNew.map(t => t.id).join(", ")}`, "t");
        }

        // Update state
        state.tracker.tracks = newTracks;
        state.detections = newTracks; // Keep synced

    } catch (e) {
        console.warn("Track sync failed", e);
    }
};

APP.core.tracker.predictTracks = function (dtSec) {
    const { state } = APP.core;
    const { $ } = APP.core.utils;
    const videoEngage = $("#videoEngage");
    if (!videoEngage) return;
    const w = videoEngage.videoWidth || state.frame.w;
    const h = videoEngage.videoHeight || state.frame.h;

    // Simple clamp util locally or imported
    const clamp = (val, min, max) => Math.min(max, Math.max(min, val));

    state.tracker.tracks.forEach(tr => {
        if (tr.killed) return;
        tr.bbox.x = clamp(tr.bbox.x + tr.vx * dtSec * 0.12, 0, w - 1);
        tr.bbox.y = clamp(tr.bbox.y + tr.vy * dtSec * 0.12, 0, h - 1);
    });
};