Add scripts/extract_vlac2_release_frames.py

scripts/extract_vlac2_release_frames.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import tqdm
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+if str(SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_DIR))
+
+from vlac2_release_common import (
+    discover_benchmark_jsons,
+    dump_json,
+    ensure_generated_marker,
+    ensure_release_tree,
+    infer_main_path_from_row,
+    load_json,
+    normalize_main_path,
+)
+
+try:
+    import cv2  # type: ignore
+except ImportError:
+    cv2 = None
+
+try:
+    import imageio.v2 as imageio  # type: ignore
+except ImportError:
+    imageio = None
+
+
+@dataclass(frozen=True)
+class EpisodeSpec:
+    group_key: str
+    main_path: Path
+    benchmark_sources: tuple[str, ...]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Extract the portable VLAC2 release benchmark episodes into the release-local JPG tree."
+    )
+    parser.add_argument(
+        "--release-root",
+        type=Path,
+        required=True,
+        help="Release root containing benchmark_json/ and vlac2_release_data/.",
+    )
+    parser.add_argument(
+        "--raw-root",
+        type=Path,
+        default=None,
+        help="Override raw release data root. Defaults to <release-root>/vlac2_release_data.",
+    )
+    parser.add_argument(
+        "--output-root",
+        type=Path,
+        default=None,
+        help="Override extracted image root. Defaults to <release-root>/_extracted_frames.",
+    )
+    parser.add_argument(
+        "--benchmark-json",
+        action="append",
+        default=None,
+        help="Optional specific benchmark JSON(s). Defaults to discovering benchmark_json/**/*.json inside the release root.",
+    )
+    parser.add_argument(
+        "--view-mode",
+        choices=["all-available", "main-only"],
+        default="all-available",
+        help="Extract only the benchmark main view, or all sibling observation.images.* views for the referenced episode.",
+    )
+    parser.add_argument("--jobs", type=int, default=max(1, (os.cpu_count() or 8) // 2))
+    parser.add_argument(
+        "--overwrite-existing",
+        action="store_true",
+        help="Re-extract even if an output manifest says the target episode-view is already complete.",
+    )
+    return parser.parse_args()
+
+
+def require_decoder() -> None:
+    if cv2 is None and imageio is None:
+        raise SystemExit(
+            "No video decoder available. Install opencv-python or imageio before running frame extraction."
+        )
+
+
+def benchmark_files_from_args(release_root: Path, raw_paths: list[str] | None) -> list[Path]:
+    if raw_paths:
+        return [Path(path).resolve() for path in raw_paths]
+    benchmark_root = release_root / "benchmark_json"
+    files = discover_benchmark_jsons(benchmark_root)
+    if not files:
+        raise SystemExit(f"No benchmark json found under {benchmark_root}")
+    return files
+
+
+def episode_group_key(main_path: Path) -> str:
+    parts = list(main_path.parts)
+    for idx, part in enumerate(parts):
+        if part.startswith("observation.images.") and idx + 1 < len(parts):
+            return str(Path(*parts[:idx], parts[idx + 1]))
+    return str(main_path)
+
+
+def collect_episode_specs(benchmark_paths: list[Path]) -> tuple[list[EpisodeSpec], dict[str, Any]]:
+    grouped: dict[str, tuple[Path, set[str]]] = {}
+    stats = {
+        "benchmark_files_total": len(benchmark_paths),
+        "rows_total": 0,
+        "rows_missing_main_path": 0,
+    }
+
+    for benchmark_path in benchmark_paths:
+        rows = load_json(benchmark_path)
+        if not isinstance(rows, list):
+            raise ValueError(f"Expected list json: {benchmark_path}")
+        stats["rows_total"] += len(rows)
+        for row in rows:
+            inferred_main_path = infer_main_path_from_row(row)
+            if inferred_main_path is None:
+                stats["rows_missing_main_path"] += 1
+                continue
+            normalized = normalize_main_path(inferred_main_path)
+            key = episode_group_key(normalized)
+            if key not in grouped:
+                grouped[key] = (normalized, {str(benchmark_path)})
+            else:
+                grouped[key][1].add(str(benchmark_path))
+
+    specs = [
+        EpisodeSpec(group_key=key, main_path=main_path, benchmark_sources=tuple(sorted(sources)))
+        for key, (main_path, sources) in sorted(grouped.items())
+    ]
+    stats["episodes_unique"] = len(specs)
+    return specs, stats
+
+
+def resolve_main_video(raw_root: Path, main_path: Path) -> Path:
+    candidate = raw_root / main_path
+    if candidate.suffix == ".mp4":
+        return candidate
+
+    # Keep the full main_path leaf intact when appending ".mp4" so episode
+    # identifiers containing dots (for example timestamps like "....311186")
+    # are not truncated. Fall back to with_suffix(".mp4") for compatibility
+    # with any legacy raw layouts that already dropped the tail suffix.
+    preferred = Path(f"{candidate}.mp4")
+    legacy = candidate.with_suffix(".mp4")
+    if preferred.exists() or preferred == legacy:
+        return preferred
+    if legacy.exists():
+        return legacy
+    return preferred
+
+
+def discover_view_videos(raw_root: Path, main_path: Path, view_mode: str) -> list[Path]:
+    main_video = resolve_main_video(raw_root, main_path)
+    if not main_video.exists():
+        raise FileNotFoundError(f"Missing raw video: {main_video}")
+    if view_mode == "main-only":
+        return [main_video]
+
+    chunk_dir = main_video.parent.parent
+    episode_file = main_video.name
+    discovered: list[Path] = []
+    for child in sorted(chunk_dir.iterdir()):
+        if not child.is_dir() or not child.name.startswith("observation.images."):
+            continue
+        candidate = child / episode_file
+        if candidate.exists():
+            discovered.append(candidate)
+    if main_video not in discovered:
+        discovered.insert(0, main_video)
+    return discovered
+
+
+def manifest_path_for(output_dir: Path) -> Path:
+    return output_dir / ".vlac_extract_manifest.json"
+
+
+def output_dir_from_video(raw_root: Path, output_root: Path, video_path: Path) -> Path:
+    relative = video_path.relative_to(raw_root).with_suffix("")
+    return output_root / relative
+
+
+def is_complete(output_dir: Path, source_video: Path) -> bool:
+    manifest_path = manifest_path_for(output_dir)
+    if not manifest_path.exists():
+        return False
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except Exception:
+        return False
+
+    frame_count = int(manifest.get("frame_count") or 0)
+    if frame_count <= 0:
+        return False
+    source_mtime_ns = int(source_video.stat().st_mtime_ns)
+    source_size = int(source_video.stat().st_size)
+    if int(manifest.get("source_mtime_ns") or -1) != source_mtime_ns:
+        return False
+    if int(manifest.get("source_size") or -1) != source_size:
+        return False
+
+    jpg_files = sorted(output_dir.glob("*.jpg"))
+    return len(jpg_files) == frame_count
+
+
+def clear_output_dir(output_dir: Path) -> None:
+    if not output_dir.exists():
+        return
+    for pattern in ("*.jpg", "frame_*.jpg", ".vlac_extract_manifest.json"):
+        for path in output_dir.glob(pattern):
+            if path.is_file():
+                path.unlink()
+
+
+def write_manifest(output_dir: Path, source_video: Path, frame_count: int) -> None:
+    manifest = {
+        "source_video": str(source_video),
+        "source_size": int(source_video.stat().st_size),
+        "source_mtime_ns": int(source_video.stat().st_mtime_ns),
+        "frame_count": int(frame_count),
+    }
+    manifest_path_for(output_dir).write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def extract_with_cv2(source_video: Path, output_dir: Path) -> int:
+    assert cv2 is not None
+    capture = cv2.VideoCapture(str(source_video))
+    if not capture.isOpened():
+        raise RuntimeError(f"cv2 failed to open {source_video}")
+
+    temp_paths: list[Path] = []
+    frame_idx = 0
+    try:
+        while True:
+            ok, frame = capture.read()
+            if not ok:
+                break
+            temp_path = output_dir / f"frame_{frame_idx:06d}.jpg"
+            if not cv2.imwrite(str(temp_path), frame):
+                raise RuntimeError(f"cv2 failed to write {temp_path}")
+            temp_paths.append(temp_path)
+            frame_idx += 1
+    finally:
+        capture.release()
+
+    for idx, temp_path in enumerate(temp_paths):
+        temp_path.rename(output_dir / f"{idx}-{frame_idx}.jpg")
+    return frame_idx
+
+
+def extract_with_imageio(source_video: Path, output_dir: Path) -> int:
+    assert imageio is not None
+    temp_paths: list[Path] = []
+    frame_idx = 0
+    try:
+        for frame in imageio.get_reader(str(source_video)):
+            temp_path = output_dir / f"frame_{frame_idx:06d}.jpg"
+            imageio.imwrite(str(temp_path), frame)
+            temp_paths.append(temp_path)
+            frame_idx += 1
+    except Exception as exc:
+        if frame_idx == 0:
+            raise RuntimeError(f"imageio failed to decode {source_video}: {exc}") from exc
+        raise
+    for idx, temp_path in enumerate(temp_paths):
+        temp_path.rename(output_dir / f"{idx}-{frame_idx}.jpg")
+    return frame_idx
+
+
+def extract_one_video(source_video: Path, output_dir: Path, overwrite_existing: bool) -> dict[str, Any]:
+    if not overwrite_existing and is_complete(output_dir, source_video):
+        manifest = json.loads(manifest_path_for(output_dir).read_text(encoding="utf-8"))
+        return {
+            "source_video": str(source_video),
+            "output_dir": str(output_dir),
+            "frame_count": int(manifest["frame_count"]),
+            "status": "skipped_existing",
+        }
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    clear_output_dir(output_dir)
+    if cv2 is not None:
+        frame_count = extract_with_cv2(source_video, output_dir)
+        if frame_count == 0 and imageio is not None:
+            clear_output_dir(output_dir)
+            frame_count = extract_with_imageio(source_video, output_dir)
+    elif imageio is not None:
+        frame_count = extract_with_imageio(source_video, output_dir)
+    else:
+        raise RuntimeError("No available decoder")
+    if frame_count <= 0:
+        raise RuntimeError(f"Decoder produced zero frames for {source_video}")
+    write_manifest(output_dir, source_video, frame_count)
+    return {
+        "source_video": str(source_video),
+        "output_dir": str(output_dir),
+        "frame_count": frame_count,
+        "status": "extracted",
+    }
+
+
+
+
+def main() -> None:
+    args = parse_args()
+    require_decoder()
+
+    paths = ensure_release_tree(args.release_root)
+    release_root = paths["release_root"]
+    raw_root = args.raw_root.resolve() if args.raw_root else paths["raw_root"]
+    output_root = args.output_root.resolve() if args.output_root else paths["portable_image_root"]
+    ensure_generated_marker(output_root)
+    benchmark_paths = benchmark_files_from_args(release_root, args.benchmark_json)
+
+    specs, stats = collect_episode_specs(benchmark_paths)
+    jobs: list[tuple[Path, Path]] = []
+    missing_raw_episodes: list[dict[str, str]] = []
+    for spec in specs:
+        try:
+            view_videos = discover_view_videos(raw_root, spec.main_path, args.view_mode)
+        except FileNotFoundError as exc:
+            missing_raw_episodes.append(
+                {
+                    "main_path": str(spec.main_path),
+                    "error": str(exc),
+                }
+            )
+            continue
+        for video_path in view_videos:
+            jobs.append((video_path, output_dir_from_video(raw_root, output_root, video_path)))
+
+    results: list[dict[str, Any]] = []
+    with ThreadPoolExecutor(max_workers=max(1, args.jobs)) as executor:
+        future_to_job = {
+            executor.submit(extract_one_video, video_path, output_dir, args.overwrite_existing): (video_path, output_dir)
+            for video_path, output_dir in jobs
+        }
+        for future in tqdm.tqdm(as_completed(future_to_job), total=len(future_to_job), desc="Extract release frames"):
+            video_path, output_dir = future_to_job[future]
+            try:
+                results.append(future.result())
+            except Exception as exc:
+                results.append(
+                    {
+                        "source_video": str(video_path),
+                        "output_dir": str(output_dir),
+                        "status": "error",
+                        "error": str(exc),
+                    }
+                )
+
+    summary = {
+        **stats,
+        "release_root": str(release_root),
+        "raw_root": str(raw_root),
+        "output_root": str(output_root),
+        "view_mode": args.view_mode,
+        "benchmark_files": [str(path) for path in benchmark_paths],
+        "jobs_total": len(jobs),
+        "jobs_extracted": sum(1 for row in results if row["status"] == "extracted"),
+        "jobs_skipped_existing": sum(1 for row in results if row["status"] == "skipped_existing"),
+        "jobs_failed": sum(1 for row in results if row["status"] == "error"),
+        "missing_raw_episodes": missing_raw_episodes,
+        "results": results,
+    }
+    summary_path = release_root / "frame_extraction_summary.json"
+    dump_json(summary_path, summary)
+    print(f"[frame-extraction] {summary_path}")
+
+
+if __name__ == "__main__":
+    main()