update preprocess_gt_videos.py

preprocess_gt_videos.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+eval/preprocess_gt_videos.py
+
+Apply the same spatial preprocessing used by SpaceTimePilot to the GT videos
+in camxtime_evaluation_gt, so they match the network output format exactly.
+
+Pipeline (mirrors spacetimepilot/dataset/utils.py):
+  1. Load up to 81 frames at stride=1
+  2. crop_and_resize: aspect-ratio preserving scale so image covers 832×480
+  3. CenterCrop to exactly 832×480
+  4. Pad with last frame if shorter than 81 frames
+  5. Write as 30fps H264 MP4
+
+For 1080×1080 source: scale to 832×832, then crop 176px top/bottom → 832×480.
+
+Usage (run from repo root):
+    python eval/preprocess_gt_videos.py \\
+        --input  camxtime_evaluation_gt \\
+        --output camxtime_evaluation_gt_preprocessed
+"""
+
+import argparse
+import multiprocessing
+import shutil
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import imageio.v2 as imageio
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+TARGET_W   = 832
+TARGET_H   = 480
+NUM_FRAMES = 81
+FPS        = 30
+
+
+def crop_and_resize(img: Image.Image) -> Image.Image:
+    w, h  = img.size
+    scale = max(TARGET_W / w, TARGET_H / h)
+    return img.resize((round(w * scale), round(h * scale)), Image.BILINEAR)
+
+
+def center_crop(img: Image.Image) -> Image.Image:
+    w, h = img.size
+    return img.crop(((w - TARGET_W) // 2, (h - TARGET_H) // 2,
+                     (w - TARGET_W) // 2 + TARGET_W, (h - TARGET_H) // 2 + TARGET_H))
+
+
+def preprocess_frame(arr: np.ndarray) -> np.ndarray:
+    img = Image.fromarray(arr).convert("RGB")
+    return np.array(center_crop(crop_and_resize(img)))
+
+
+def process_video(src: Path, dst: Path) -> None:
+    reader = imageio.get_reader(str(src))
+    total  = reader.count_frames()
+    frames = [preprocess_frame(reader.get_data(i)) for i in range(min(NUM_FRAMES, total))]
+    reader.close()
+    while len(frames) < NUM_FRAMES:
+        frames.append(frames[-1].copy())
+    writer = imageio.get_writer(str(dst), fps=FPS, codec="libx264", quality=8)
+    for f in frames:
+        writer.append_data(f)
+    writer.close()
+
+
+def process_scene(args):
+    scene_dir, out_dir = Path(args[0]), Path(args[1])
+    out_scene = out_dir / scene_dir.name
+    out_scene.mkdir(parents=True, exist_ok=True)
+    n_built = n_skipped = 0
+    for vid in sorted(scene_dir.glob("*.mp4")):
+        out_vid = out_scene / vid.name
+        if out_vid.exists():
+            n_skipped += 1
+        else:
+            process_video(vid, out_vid)
+            n_built += 1
+        for ext in (".json", ".txt"):
+            src = vid.with_suffix(ext)
+            if src.exists():
+                dst = out_scene / src.name
+                if not dst.exists():
+                    shutil.copy2(src, dst)
+    cam_json = scene_dir / "camera_data.json"
+    if cam_json.exists() and not (out_scene / "camera_data.json").exists():
+        shutil.copy2(cam_json, out_scene / "camera_data.json")
+    return scene_dir.name, n_built, n_skipped
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Preprocess GT videos to 832×480 / 81 frames to match network output."
+    )
+    parser.add_argument("--input",   required=True,
+                        help="camxtime_evaluation_gt root")
+    parser.add_argument("--output",  required=True,
+                        help="Output root (camxtime_evaluation_gt_preprocessed)")
+    parser.add_argument("--scenes",  nargs="+")
+    parser.add_argument("--workers", type=int,
+                        default=min(32, multiprocessing.cpu_count()))
+    args = parser.parse_args()
+
+    input_dir  = Path(args.input)
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    scenes = ([input_dir / s for s in args.scenes] if args.scenes
+              else sorted(p for p in input_dir.iterdir() if p.is_dir()))
+
+    print(f"CPUs: {multiprocessing.cpu_count()}  |  workers: {args.workers}  "
+          f"|  target: {TARGET_W}×{TARGET_H}, {NUM_FRAMES}f @ {FPS}fps  "
+          f"|  scenes: {len(scenes)}\n")
+
+    tasks = [(s, output_dir) for s in scenes]
+    n_done = n_errors = 0
+
+    with ProcessPoolExecutor(max_workers=args.workers) as pool:
+        futures = {pool.submit(process_scene, t): Path(t[0]).name for t in tasks}
+        with tqdm(total=len(futures), desc="Overall", unit="scene",
+                  dynamic_ncols=True) as pbar:
+            for fut in as_completed(futures):
+                name = futures[fut]
+                try:
+                    _, built, skipped = fut.result()
+                    n_done += 1
+                    tqdm.write(f"  OK    {name:<12s}  {built} preprocessed, {skipped} skipped")
+                except Exception as exc:
+                    n_errors += 1
+                    tqdm.write(f"  ERR   {name:<12s}  {exc}")
+                pbar.set_postfix(done=n_done, err=n_errors)
+                pbar.update(1)
+
+    print(f"\nFinished — {n_done} scenes done, {n_errors} errors")
+    print(f"Output: {output_dir}")
+
+
+if __name__ == "__main__":
+    main()