main.py

import argparse
from pathlib import Path
import subprocess
from dataclasses import dataclass

import cv2
import numpy as np
import pandas as pd
from tqdm import tqdm
from ultralytics import YOLO
from filterpy.kalman import KalmanFilter


def run_cmd(cmd: list[str]) -> None:
    p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    if p.returncode != 0:
        raise RuntimeError(f"Command failed:\n{' '.join(cmd)}\n\nSTDERR:\n{p.stderr}")


def extract_frames_ffmpeg(video_path: Path, out_dir: Path, fps: float) -> None:
    out_dir.mkdir(parents=True, exist_ok=True)
    cmd = [
        "ffmpeg", "-y",
        "-i", str(video_path),
        "-vf", f"fps={fps}",
        str(out_dir / "frame_%04d.jpg")
    ]
    run_cmd(cmd)


def list_frames(frame_dir: Path) -> list[Path]:
    return sorted(frame_dir.glob("frame_*.jpg"))


def xyxy_to_center(xyxy: np.ndarray) -> tuple[float, float]:
    x1, y1, x2, y2 = xyxy
    return float((x1 + x2) / 2.0), float((y1 + y2) / 2.0)


def clip_box(x1, y1, x2, y2, w, h):
    x1 = max(0, min(int(x1), w - 1))
    y1 = max(0, min(int(y1), h - 1))
    x2 = max(0, min(int(x2), w - 1))
    y2 = max(0, min(int(y2), h - 1))
    if x2 <= x1: x2 = min(w - 1, x1 + 1)
    if y2 <= y1: y2 = min(h - 1, y1 + 1)
    return x1, y1, x2, y2


@dataclass
class TrackConfig:
    dt: float = 1.0
    process_var: float = 20.0
    meas_var: float = 50.0
    max_missed: int = 8


class SingleKalmanTrack:
    """
    Single-object Kalman track.
    State: [x, y, vx, vy]
    Measurement: [x, y]
    """
    def __init__(self, initial_xy: tuple[float, float], initial_wh: tuple[float, float], cfg: TrackConfig):
        self.cfg = cfg
        self.kf = KalmanFilter(dim_x=4, dim_z=2)

        dt = cfg.dt
        self.kf.F = np.array([
            [1, 0, dt, 0],
            [0, 1, 0, dt],
            [0, 0, 1, 0 ],
            [0, 0, 0, 1 ],
        ], dtype=float)

        self.kf.H = np.array([
            [1, 0, 0, 0],
            [0, 1, 0, 0],
        ], dtype=float)

        x0, y0 = initial_xy
        self.kf.x = np.array([x0, y0, 0.0, 0.0], dtype=float)

        self.kf.P *= 500.0
        self.kf.R = np.eye(2) * cfg.meas_var
        self.kf.Q = np.eye(4) * cfg.process_var

        self.last_w, self.last_h = initial_wh
        self.missed = 0
        self.trajectory = [(x0, y0)]

    def predict(self):
        self.kf.predict()
        return float(self.kf.x[0]), float(self.kf.x[1])

    def update(self, meas_xy: tuple[float, float] | None, meas_wh: tuple[float, float] | None):
        if meas_xy is None:
            self.missed += 1
            self.trajectory.append((float(self.kf.x[0]), float(self.kf.x[1])))
            return False

        z = np.array([[meas_xy[0]], [meas_xy[1]]], dtype=float)
        self.kf.update(z)
        self.missed = 0

        if meas_wh is not None:
            w, h = meas_wh
            self.last_w = 0.8 * self.last_w + 0.2 * w
            self.last_h = 0.8 * self.last_h + 0.2 * h

        self.trajectory.append((float(self.kf.x[0]), float(self.kf.x[1])))
        return True

    def alive(self) -> bool:
        return self.missed <= self.cfg.max_missed

    def current_box_xyxy(self):
        x, y = float(self.kf.x[0]), float(self.kf.x[1])
        w, h = float(self.last_w), float(self.last_h)
        return (x - w/2, y - h/2, x + w/2, y + h/2)


def pick_best_detection(result, conf_thres: float):
    if result.boxes is None or len(result.boxes) == 0:
        return None
    boxes = result.boxes
    xyxy = boxes.xyxy.cpu().numpy()
    conf = boxes.conf.cpu().numpy()
    keep = conf >= conf_thres
    if not np.any(keep):
        return None
    xyxy = xyxy[keep]
    conf = conf[keep]
    best_i = int(np.argmax(conf))
    return xyxy[best_i], float(conf[best_i])


def draw_overlay(img, xyxy, traj_points):
    h, w = img.shape[:2]
    x1, y1, x2, y2 = xyxy
    x1, y1, x2, y2 = clip_box(x1, y1, x2, y2, w, h)

    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)

    if len(traj_points) >= 2:
        pts = np.array([[int(x), int(y)] for (x, y) in traj_points], dtype=np.int32)
        cv2.polylines(img, [pts], isClosed=False, color=(255, 0, 0), thickness=2)

    return img


def process_video(video_path: Path, model: YOLO, out_root: Path, fps: float, conf_thres: float, track_cfg: TrackConfig):
    video_name = video_path.stem

    frames_dir = out_root / "frames" / video_name
    det_frames_dir = out_root / "detections" / video_name
    tracks_dir = out_root / "tracks" / video_name

    det_frames_dir.mkdir(parents=True, exist_ok=True)
    tracks_dir.mkdir(parents=True, exist_ok=True)

    extract_frames_ffmpeg(video_path, frames_dir, fps)
    frames = list_frames(frames_dir)
    if not frames:
        print(f"[WARN] No frames extracted for {video_path}")
        return

    det_rows = []
    output_frames = []
    tracker = None

    for frame_path in tqdm(frames, desc=f"Processing {video_name}"):
        img = cv2.imread(str(frame_path))
        if img is None:
            continue

        results = model.predict(source=img, verbose=False)
        r = results[0]

        best = pick_best_detection(r, conf_thres=conf_thres)
        meas_xy = None
        meas_wh = None
        meas_xyxy = None
        det_conf = None

        if best is not None:
            meas_xyxy, det_conf = best
            cx, cy = xyxy_to_center(meas_xyxy)
            meas_xy = (cx, cy)
            w_box = float(meas_xyxy[2] - meas_xyxy[0])
            h_box = float(meas_xyxy[3] - meas_xyxy[1])
            meas_wh = (w_box, h_box)

            out_det_frame = det_frames_dir / frame_path.name
            cv2.imwrite(str(out_det_frame), img)

            det_rows.append({
                "video": video_name,
                "frame_file": frame_path.name,
                "conf": det_conf,
                "x1": float(meas_xyxy[0]),
                "y1": float(meas_xyxy[1]),
                "x2": float(meas_xyxy[2]),
                "y2": float(meas_xyxy[3]),
                "cx": float(cx),
                "cy": float(cy),
            })

        if tracker is None:
            if meas_xy is not None and meas_wh is not None:
                tracker = SingleKalmanTrack(meas_xy, meas_wh, track_cfg)
                tracker.predict()
                tracker.update(meas_xy, meas_wh)
            else:
                continue
        else:
            tracker.predict()
            tracker.update(meas_xy, meas_wh)

        if tracker is not None and tracker.alive():
            if meas_xyxy is not None:
                draw_xyxy = meas_xyxy
            else:
                draw_xyxy = np.array(tracker.current_box_xyxy(), dtype=float)

            overlay = img.copy()
            overlay = draw_overlay(overlay, draw_xyxy, tracker.trajectory)

            out_annot = tracks_dir / frame_path.name
            cv2.imwrite(str(out_annot), overlay)
            output_frames.append(overlay)

    det_df = pd.DataFrame(det_rows)
    parquet_path = out_root / "detections" / f"{video_name}_detections.parquet"
    det_df.to_parquet(parquet_path, index=False)

    if output_frames:
        h, w = output_frames[0].shape[:2]
        out_video_path = out_root / "outputs" / f"{video_name}_tracked.mp4"
        out_video_path.parent.mkdir(parents=True, exist_ok=True)

        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
        writer = cv2.VideoWriter(str(out_video_path), fourcc, fps, (w, h))
        for f in output_frames:
            writer.write(f)
        writer.release()

        print(f"[OK] Wrote {out_video_path}")
        print(f"[OK] Detections parquet: {parquet_path}")
        print(f"[OK] Detection frames folder: {det_frames_dir}")
    else:
        print(f"[WARN] No output frames for {video_name} (tracker never initialized?)")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--videos_dir", type=str, default="videos")
    ap.add_argument("--model", type=str, required=True)
    ap.add_argument("--out_dir", type=str, default="artifacts")
    ap.add_argument("--fps", type=float, default=5.0)
    ap.add_argument("--conf", type=float, default=0.25)
    ap.add_argument("--process_var", type=float, default=20.0)
    ap.add_argument("--meas_var", type=float, default=50.0)
    ap.add_argument("--max_missed", type=int, default=8)
    args = ap.parse_args()

    videos_dir = Path(args.videos_dir)
    out_root = Path(args.out_dir)
    out_root.mkdir(parents=True, exist_ok=True)

    model = YOLO(args.model)
    cfg = TrackConfig(dt=1.0, process_var=args.process_var, meas_var=args.meas_var, max_missed=args.max_missed)

    mp4s = sorted(videos_dir.glob("*.mp4"))
    if not mp4s:
        raise FileNotFoundError(f"No .mp4 files found in {videos_dir}")

    for vp in mp4s:
        process_video(vp, model, out_root, args.fps, args.conf, cfg)


if __name__ == "__main__":
    main()