scripts/prepare_spatialvid_csv.py

#!/usr/bin/env python3
"""Build a LiveWorld four-field CSV from SpatialVID_preped.

SpatialVID / LongLive i2v assets:
  - sampled_clippath.csv          -> prompt + clipPath
  - <video_root>/<clipPath>       -> first-frame image
  - clip_annotation/<stem>/longlive/scene_projection_input.mp4  (81 frames)
  - clip_annotation/<stem>/longlive/fg_projection_input.mp4     (81 frames)

LiveWorld ``condition_source=mp4`` with ``num_frames=81`` indexes projection
videos at global indices ``1..81`` (first_frame is separate at index 0).
So an 81-frame LongLive control must be padded to 82 frames:

    lw_proj = [pad_frame] + longlive_proj[0..80]

then LiveWorld targets ``1..81`` consume the original 81 LongLive frames.

Pad policy:
  - bg: first frame of the source clip (same as input_image)
  - fg: black frame (FG at t=0 lives in the RGB image)

Writes per stem under ``--output-root/<stem>/``:
  first_frame.png, bg_projection.mp4, fg_projection.mp4

and a CSV (paths relative to the CSV file location):
  name,input_image,text,bg_projection,fg_projection
"""
from __future__ import annotations

import argparse
import csv
import sys
from pathlib import Path
from typing import Optional, Tuple

import cv2
import numpy as np
from tqdm import tqdm


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument(
        "--csv",
        type=Path,
        default=Path(
            "/home/zhangzhiyuan/VAM_projs/realbench_comp/"
            "SpatialVID_preped/sampled_clippath.csv"
        ),
    )
    p.add_argument(
        "--video-root",
        type=Path,
        default=Path(
            "/home/zhangzhiyuan/VAM_projs/realbench_comp/SpatialVID_preped"
        ),
        help="Directory containing <clipPath> mp4s",
    )
    p.add_argument(
        "--annotation-root",
        type=Path,
        default=Path(
            "/home/zhangzhiyuan/VAM_projs/realbench_comp/"
            "SpatialVID_preped/clip_annotation"
        ),
    )
    p.add_argument(
        "--output-root",
        type=Path,
        default=Path(__file__).resolve().parents[1] / "liveworld_i2v_inputs",
        help="Per-case first_frame + padded 82-frame projections "
             "(default: LiveWorld_comp/liveworld_i2v_inputs)",
    )
    p.add_argument(
        "--out-csv",
        type=Path,
        default=Path(__file__).resolve().parents[1] / "liveworld_i2v_cases.csv",
        help="Output CSV path (default: LiveWorld_comp/liveworld_i2v_cases.csv)",
    )
    p.add_argument("--fps", type=float, default=16.0,
                   help="FPS for written projection mp4s (LiveWorld default 16)")
    p.add_argument("--target-hw", type=int, nargs=2, default=[480, 832],
                   metavar=("H", "W"),
                   help="Resize first_frame / projections to this HxW")
    p.add_argument("--overwrite", action="store_true")
    p.add_argument("--limit", type=int, default=None)
    p.add_argument("--stems", nargs="*", default=None,
                   help="Only process these stems (default: all csv rows)")
    return p.parse_args()


def read_video_bgr(path: Path) -> list:
    cap = cv2.VideoCapture(str(path))
    if not cap.isOpened():
        raise FileNotFoundError(f"cannot open video: {path}")
    frames = []
    while True:
        ok, frame = cap.read()
        if not ok:
            break
        frames.append(frame)
    cap.release()
    if not frames:
        raise RuntimeError(f"empty video: {path}")
    return frames


def write_video_bgr(path: Path, frames: list, fps: float) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    h, w = frames[0].shape[:2]
    writer = cv2.VideoWriter(
        str(path),
        cv2.VideoWriter_fourcc(*"mp4v"),
        float(fps),
        (w, h),
    )
    if not writer.isOpened():
        raise RuntimeError(f"failed to open VideoWriter: {path}")
    for f in frames:
        writer.write(f)
    writer.release()


def resize_bgr(frame: np.ndarray, target_hw: Tuple[int, int]) -> np.ndarray:
    H, W = target_hw
    if frame.shape[0] == H and frame.shape[1] == W:
        return frame
    return cv2.resize(frame, (W, H), interpolation=cv2.INTER_LINEAR)


def pad_projection_to_82(
    frames_81: list,
    pad_frame: np.ndarray,
    target_hw: Tuple[int, int],
) -> list:
    """Prepend pad_frame so LiveWorld indices 1..81 map to original 0..80."""
    if len(frames_81) != 81:
        raise ValueError(f"expected 81 frames, got {len(frames_81)}")
    pad = resize_bgr(pad_frame, target_hw)
    body = [resize_bgr(f, target_hw) for f in frames_81]
    return [pad] + body


def process_one(
    stem: str,
    prompt: str,
    video_path: Path,
    annotation_root: Path,
    output_root: Path,
    fps: float,
    target_hw: Tuple[int, int],
    overwrite: bool,
) -> Optional[dict]:
    ll_dir = annotation_root / stem / "longlive"
    bg_src = ll_dir / "scene_projection_input.mp4"
    fg_src = ll_dir / "fg_projection_input.mp4"
    if not bg_src.exists() or not fg_src.exists():
        print(f"[skip] missing projections: {stem}", file=sys.stderr)
        return None
    if not video_path.exists():
        print(f"[skip] missing video: {video_path}", file=sys.stderr)
        return None

    out_dir = output_root / stem
    first_path = out_dir / "first_frame.png"
    bg_out = out_dir / "bg_projection.mp4"
    fg_out = out_dir / "fg_projection.mp4"

    if (
        not overwrite
        and first_path.exists()
        and bg_out.exists()
        and fg_out.exists()
    ):
        return {
            "name": stem,
            "input_image": first_path,
            "text": prompt,
            "bg_projection": bg_out,
            "fg_projection": fg_out,
        }

    src_frames = read_video_bgr(video_path)
    first_bgr = resize_bgr(src_frames[0], target_hw)
    out_dir.mkdir(parents=True, exist_ok=True)
    cv2.imwrite(str(first_path), first_bgr)

    bg_81 = read_video_bgr(bg_src)
    fg_81 = read_video_bgr(fg_src)
    if len(bg_81) != 81 or len(fg_81) != 81:
        print(
            f"[skip] {stem}: expected 81-frame projections, "
            f"got bg={len(bg_81)} fg={len(fg_81)}",
            file=sys.stderr,
        )
        return None

    H, W = target_hw
    black = np.zeros((H, W, 3), dtype=np.uint8)
    bg_82 = pad_projection_to_82(bg_81, first_bgr, target_hw)
    fg_82 = pad_projection_to_82(fg_81, black, target_hw)
    write_video_bgr(bg_out, bg_82, fps)
    write_video_bgr(fg_out, fg_82, fps)

    return {
        "name": stem,
        "input_image": first_path,
        "text": prompt,
        "bg_projection": bg_out,
        "fg_projection": fg_out,
    }


def main() -> None:
    args = parse_args()
    target_hw = (int(args.target_hw[0]), int(args.target_hw[1]))
    wanted = set(args.stems) if args.stems else None

    with args.csv.open("r", encoding="utf-8-sig", newline="") as f:
        rows = list(csv.DictReader(f))
    if not rows:
        raise SystemExit(f"empty csv: {args.csv}")

    selected = []
    for r in rows:
        clip = (r.get("clipPath") or "").strip()
        if not clip:
            continue
        stem = Path(clip).stem
        if wanted is not None and stem not in wanted:
            continue
        selected.append((stem, (r.get("prompt") or "").strip(), clip))
    if args.limit is not None:
        selected = selected[: args.limit]

    args.output_root.mkdir(parents=True, exist_ok=True)
    out_rows = []
    n_fail = 0
    for stem, prompt, clip in tqdm(selected, desc="prepare liveworld i2v"):
        if not prompt:
            print(f"[skip] empty prompt: {stem}", file=sys.stderr)
            n_fail += 1
            continue
        video_path = args.video_root / clip
        try:
            row = process_one(
                stem=stem,
                prompt=prompt,
                video_path=video_path,
                annotation_root=args.annotation_root,
                output_root=args.output_root,
                fps=args.fps,
                target_hw=target_hw,
                overwrite=args.overwrite,
            )
        except Exception as e:  # noqa: BLE001
            n_fail += 1
            print(f"[FAIL] {stem}: {e}", file=sys.stderr)
            continue
        if row is None:
            n_fail += 1
            continue
        out_rows.append(row)

    args.out_csv.parent.mkdir(parents=True, exist_ok=True)
    csv_base = args.out_csv.resolve().parent

    def _rel(p: Path) -> str:
        try:
            return str(p.resolve().relative_to(csv_base))
        except ValueError:
            return str(p.resolve())

    csv_rows = [
        {
            "name": r["name"],
            "input_image": _rel(Path(r["input_image"])),
            "text": r["text"],
            "bg_projection": _rel(Path(r["bg_projection"])),
            "fg_projection": _rel(Path(r["fg_projection"])),
        }
        for r in out_rows
    ]
    with args.out_csv.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(
            f,
            fieldnames=[
                "name", "input_image", "text", "bg_projection", "fg_projection",
            ],
            quoting=csv.QUOTE_MINIMAL,
        )
        writer.writeheader()
        writer.writerows(csv_rows)

    print(
        f"[done] wrote {len(csv_rows)} rows -> {args.out_csv} "
        f"(fail/skip={n_fail}, inputs={args.output_root})"
    )


if __name__ == "__main__":
    main()