Upload 5 files

drone_video_1_detections.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eca0b9f7c5d991e96c18366aa9365a2c002280a43de82356fa512af179117dc2
+size 7986

drone_video_1_tracked.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b566f8191923737ec3fc4f65ae6983b643a51ea98e4f5eef98bd4d3131e1ee1c
+size 1877959

drone_video_2_detections.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2fd0f4d9360c532e6774fdad93849e6bd498b8250253564bcd1b31772e0a3f2
+size 16534

drone_video_2_tracked.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d23651954cc4d80b18abd3e0a3000dc65402bd05a08021b443f25fdb5cbfeba3
+size 5690498

main.py

@@ -0,0 +1,283 @@
+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()