Upload reconstruct_ego4d_frames.py with huggingface_hub

reconstruct_ego4d_frames.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""Rebuild `obs_frame.png` for the Ego4D-derived samples of AFUN_pool.
+
+AFUN_pool ships every annotation for these samples (affordance mask, 3D motion,
+camera intrinsics, instruction) but NOT the RGB frame or the depth map: the
+Ego4D license permits distributing annotations, not the imagery itself. Each
+sample's `provenance.json` therefore points at the exact Ego4D video frame the
+annotation was made on. This script decodes that frame from your own Ego4D
+download and writes it next to the annotations, so the sample folder ends up in
+the same 3-file layout as the rest of the release
+(`obs_frame.png`, `sam_mask.png`, `trajectory.json`).
+
+Steps
+-----
+1. Get Ego4D access (sign the license at https://ego4d-data.org) and download
+   the full-scale videos for the UIDs used here:
+
+       python reconstruct_ego4d_frames.py --pool-root AFUN_pool/ego4d --list-uids > uids.txt
+       ego4d --output_directory ~/ego4d --datasets full_scale --version v2 \
+             --video_uid_file uids.txt
+
+   which yields `~/ego4d/v2/full_scale/<uid>.mp4`.
+
+2. Decode the frames (PyAV required: `pip install av`):
+
+       python reconstruct_ego4d_frames.py --pool-root AFUN_pool/ego4d --ego4d-root ~/ego4d
+
+   `--verify` additionally checks every decoded frame against the pixel hash
+   recorded in `provenance.json`, so you know the reconstruction is exact.
+
+Decoding is done exactly the way the frames were extracted originally: PyAV,
+seek to the keyframe before the target, decode forward, frame index =
+round(pts * time_base * fps), `to_ndarray(format="rgb24")`, no resizing.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+
+PROV_NAME = "provenance.json"
+
+
+def pixel_sha256(rgb: np.ndarray) -> str:
+    """Hash of the raw H×W×3 uint8 pixels — independent of PNG encoder settings."""
+    return hashlib.sha256(np.ascontiguousarray(rgb, dtype=np.uint8).tobytes()).hexdigest()
+
+
+def iter_samples(pool_root: Path):
+    """Yield (sample_dir, provenance) for every sample under pool_root."""
+    for prov_path in sorted(pool_root.rglob(PROV_NAME)):
+        yield prov_path.parent, json.loads(prov_path.read_text())
+
+
+def open_video(path: Path):
+    import av  # noqa: WPS433  (imported lazily so --list-uids works without PyAV)
+
+    container = av.open(str(path))
+    stream = container.streams.video[0]
+    fps = float(stream.average_rate) if stream.average_rate else 30.0
+    return container, stream, fps
+
+
+def decode_frame(container, stream, fps: float, frame_idx: int, last_frame: int) -> tuple[np.ndarray, int]:
+    """Decode `frame_idx`, reusing the open stream when reading forward.
+
+    Mirrors the original extraction code: seek only when moving backwards (or on
+    the first read), then decode forward until the target index is reached.
+    Returns (rgb, last_decoded_frame_index).
+    """
+    if frame_idx <= last_frame or last_frame < 0:
+        seek_pts = int((frame_idx / fps) / stream.time_base)
+        container.seek(seek_pts, stream=stream, any_frame=False, backward=True)
+        last_frame = -1
+    for frame in container.decode(stream):
+        if frame.pts is None:
+            continue
+        cur = int(float(frame.pts * stream.time_base) * fps + 0.5)
+        last_frame = cur
+        if cur >= frame_idx:
+            rgb = frame.to_ndarray(format="rgb24")
+            if rgb.ndim == 2:
+                rgb = np.stack([rgb] * 3, axis=-1)
+            elif rgb.shape[2] == 4:
+                rgb = rgb[:, :, :3]
+            return rgb.astype(np.uint8), last_frame
+    raise IndexError(f"frame {frame_idx} not reachable (last decoded {last_frame})")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--pool-root", type=Path, required=True,
+                    help="Directory holding the Ego4D-derived AFUN_pool samples (contains provenance.json files)")
+    ap.add_argument("--ego4d-root", type=Path,
+                    help="Your Ego4D download root; videos are expected at <root>/v2/full_scale/<uid>.mp4")
+    ap.add_argument("--list-uids", action="store_true",
+                    help="Print the Ego4D video UIDs needed (one per line) and exit")
+    ap.add_argument("--verify", action="store_true",
+                    help="Compare each decoded frame's pixel hash with provenance.json")
+    ap.add_argument("--overwrite", action="store_true", help="Re-decode even if obs_frame.png exists")
+    args = ap.parse_args()
+
+    samples = list(iter_samples(args.pool_root))
+    if not samples:
+        sys.exit(f"no {PROV_NAME} found under {args.pool_root}")
+
+    if args.list_uids:
+        for uid in sorted({p["ego4d_video_uid"] for _, p in samples}):
+            print(uid)
+        return 0
+    if args.ego4d_root is None:
+        sys.exit("--ego4d-root is required unless --list-uids is given")
+
+    from PIL import Image  # noqa: WPS433
+
+    # Group by video so each file is opened once and read mostly forward.
+    by_video: dict[str, list] = defaultdict(list)
+    for d, p in samples:
+        by_video[p["ego4d_video_uid"]].append((p["ego4d_frame_index"], d, p))
+
+    n_ok = n_skip = n_bad = n_missing_video = 0
+    for uid, items in sorted(by_video.items()):
+        video = args.ego4d_root / "v2" / "full_scale" / f"{uid}.mp4"
+        if not video.is_file():
+            n_missing_video += 1
+            print(f"[missing video] {video}  ({len(items)} samples)", file=sys.stderr)
+            continue
+        container, stream, fps = open_video(video)
+        last = -1
+        for frame_idx, sample_dir, prov in sorted(items):
+            out = sample_dir / "obs_frame.png"
+            if out.exists() and not args.overwrite and not args.verify:
+                n_skip += 1
+                continue
+            try:
+                rgb, last = decode_frame(container, stream, fps, frame_idx, last)
+            except Exception as e:  # keep going; report at the end
+                n_bad += 1
+                print(f"[decode failed] {sample_dir}: {e}", file=sys.stderr)
+                continue
+            if args.verify and prov.get("rgb_sha256") and pixel_sha256(rgb) != prov["rgb_sha256"]:
+                n_bad += 1
+                print(f"[hash mismatch] {sample_dir} frame {frame_idx}", file=sys.stderr)
+                continue
+            if not out.exists() or args.overwrite:
+                Image.fromarray(rgb).save(out)
+            n_ok += 1
+        container.close()
+
+    print(f"done: {n_ok} frames written/verified, {n_skip} skipped (already present), "
+          f"{n_bad} failed, {n_missing_video} videos missing")
+    return 1 if (n_bad or n_missing_video) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())