#!/usr/bin/env python """Assemble one capture into the HuggingFace staging tree. staging/data//videos/cam00.mp4 .. cam31.mp4 hardlink to frameset-videos/NN.mp4 staging/data//cameras.json copy of the capture calibration staging/data//smplx.npz written by consolidate_smplx.py staging/data//preview.jpg written by make_previews.py staging/data//capture.json machine-readable capture card Videos are HARDLINKED (same filesystem, /mnt/sdb) so staging costs ~0 bytes and the source capture dir is never modified. Falls back to symlink, then copy. The source `frameset-videos/` must already be extracted (`7z x frameset-videos.7z`); --extract will do it if the directory is missing. Usage: python stage_capture.py P1C1 --staging /mnt/sdb/degas_project/DREAMS-AVATAR-hf/staging """ from __future__ import annotations import argparse import json import os import shutil import subprocess import sys from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from load_capture import VIDEO_FRAME_OFFSET # noqa: E402 single source of truth for d DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET") # The published set is 10 captures. C1 = train, C2 = test. # P1..P4 ship both sessions; P5/P6 are CROSS-REENACT DRIVING ONLY, so only their C2 is # published. P5C1 does not exist on disk at all; P6C1 exists but is deliberately excluded. INCLUDED = ["P1C1", "P1C2", "P2C1", "P2C2", "P3C1", "P3C2", "P4C1", "P4C2", "P5C2", "P6C2"] EXCLUDED = { "P5C1": "does not exist", "P6C1": "excluded on purpose: P5/P6 contribute cross-reenact driving (C2) only", } def link_or_copy(src: Path, dst: Path) -> str: if dst.exists() or dst.is_symlink(): dst.unlink() dst.parent.mkdir(parents=True, exist_ok=True) try: os.link(src, dst) return "hardlink" except OSError: try: dst.symlink_to(src) return "symlink" except OSError: shutil.copy2(src, dst) return "copy" def probe_video(path: Path) -> dict: out = subprocess.run( ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,nb_frames,r_frame_rate,codec_name,pix_fmt", "-of", "json", str(path)], capture_output=True, text=True, check=True).stdout s = json.loads(out)["streams"][0] num, den = s["r_frame_rate"].split("/") return {"width": int(s["width"]), "height": int(s["height"]), "n_frames": int(s["nb_frames"]), "fps": round(int(num) / int(den), 4), "codec": s["codec_name"], "pix_fmt": s["pix_fmt"]} def stage(capture: str, dataset_root: Path, staging: Path, extract: bool = False, force: bool = False) -> dict: if capture in EXCLUDED and not force: raise SystemExit( f"{capture} is NOT part of DREAMS-AVATAR: {EXCLUDED[capture]}.\n" f"published captures: {', '.join(INCLUDED)} (--force to override)") if capture not in INCLUDED and not force: raise SystemExit(f"{capture} is not in the published set " f"({', '.join(INCLUDED)}); use --force to add it anyway") src = dataset_root / capture if not src.is_dir(): raise SystemExit(f"no such capture: {src}") vdir = src / "frameset-videos" if not vdir.is_dir() or not list(vdir.glob("*.mp4")): if not extract: raise SystemExit(f"{vdir} empty; re-run with --extract (runs 7z x)") arc = src / "frameset-videos.7z" print(f"[stage] extracting {arc} ...", flush=True) subprocess.run(["7z", "x", "-y", f"-o{src}", str(arc)], check=True, stdout=subprocess.DEVNULL) mp4s = sorted(vdir.glob("*.mp4")) dst = staging / "data" / capture mode = None total = 0 for m in mp4s: cam = int(m.stem) mode = link_or_copy(m, dst / "videos" / f"cam{cam:02d}.mp4") total += m.stat().st_size print(f"[stage] {capture}: {len(mp4s)} videos via {mode} " f"({total / 2**30:.2f} GiB)", flush=True) cams_src = src / "cameras.json" shutil.copy2(cams_src, dst / "cameras.json") cams = json.loads(cams_src.read_text()) n_rigs = len(cams["rigs"]) v0 = probe_video(mp4s[0]) assert v0["width"] % 2 == 0 card = { "capture": capture, "subject": capture[:2], "session": capture[2:], "role": ("train" if capture.endswith("C1") else ("cross_reenact_driving" if capture[:2] in ("P5", "P6") else "test")), "n_cams": len(mp4s), "n_rigs_in_calibration": n_rigs, "video": {**v0, "layout": "side-by-side: LEFT half = RGB, RIGHT half = alpha matte", "rgb_width": v0["width"] // 2}, "video_bytes": total, "frame_convention": { "offset_d": VIDEO_FRAME_OFFSET, "rule": "video frame index == smplx frame index == GT frame index (d=0)", "smplx_frame": "0-based frame id, stored in smplx.npz['frames']", "video_frame": "the same number, 0-based index into camNN.mp4", "measured": "d is measured per capture by verify_alignment.py, not assumed", }, "camera_convention": { "K": "[[fx,0,cx],[0,fy,cy],[0,0,1]] from rigs[i].cameras[0]", "R_w2c": "R @ diag(1,-1,-1)", "t_w2c": "-R @ c", "note": "cameras.json world is Y-down; the world_flip puts the fit in the " "same Y-up world as the DEGAS GT", }, } smplx_npz = dst / "smplx.npz" if smplx_npz.exists(): import numpy as np z = np.load(smplx_npz, allow_pickle=False) card["n_frames"] = int(len(z["frames"])) card["frame_range"] = [int(z["frames"][0]), int(z["frames"][-1])] card["smplx_kwargs"] = json.loads(str(z["smplx_kwargs"])) (dst / "capture.json").write_text(json.dumps(card, indent=2) + "\n") print(f"[stage] wrote {dst / 'capture.json'}", flush=True) return card def main() -> int: ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("capture") ap.add_argument("--dataset-root", type=Path, default=DATASET_ROOT) ap.add_argument("--staging", type=Path, required=True) ap.add_argument("--extract", action="store_true", help="7z x frameset-videos.7z if missing") ap.add_argument("--force", action="store_true", help="stage a capture outside the published 10 (P5C1/P6C1 are excluded)") a = ap.parse_args() print(json.dumps(stage(a.capture, a.dataset_root, a.staging, a.extract, a.force))) return 0 if __name__ == "__main__": sys.exit(main())