| |
| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
|
|
| KNOWN_DATASET_NAMES = ( |
| "ARX-data", |
| "dex_fold_v2_mix", |
| "droid_lerobot", |
| "libero", |
| "libero_zty50", |
| "VLABench_5", |
| ) |
| KNOWN_VIDEO_SUFFIXES = {".mp4", ".avi", ".mov", ".mkv", ".webm"} |
| PORTABLE_IMAGE_ROOT = Path("_extracted_frames") |
| LEGACY_PORTABLE_IMAGE_ROOTS = ( |
| Path("extracted_frames"), |
| Path("progress_data") / "VLAC_preprocessed_data" / "data", |
| ) |
| GENERATED_MARKER_FILENAME = "_GENERATED" |
| PUBLIC_BENCHMARK_JSON_NAME = "video_progress_benchmark_file.json" |
| PUBLIC_RELEASE_ROOT_PLACEHOLDER = "__VLAC2_RELEASE_ROOT__" |
| PUBLIC_FRAMES_ROOT_PLACEHOLDER = "__VLAC2_FRAMES_ROOT__" |
| PUBLIC_BENCHMARK_DIRNAME = "benchmark_splits" |
| FULL_RELEASE_BENCHMARK_DIRNAME = "benchmark_style_all" |
| LEGACY_BENCHMARK_DIRNAME = "benchmark_json" |
|
|
|
|
| def portable_image_roots() -> tuple[Path, ...]: |
| roots = [PORTABLE_IMAGE_ROOT, *LEGACY_PORTABLE_IMAGE_ROOTS] |
| deduped: list[Path] = [] |
| seen: set[tuple[str, ...]] = set() |
| for root in roots: |
| key = root.parts |
| if key in seen: |
| continue |
| seen.add(key) |
| deduped.append(root) |
| return tuple(deduped) |
|
|
|
|
| def load_json(path: Path) -> Any: |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def dump_json(path: Path, payload: Any) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
|
|
|
|
| def ensure_generated_marker(output_root: Path) -> Path: |
| output_root.mkdir(parents=True, exist_ok=True) |
| marker_path = output_root / GENERATED_MARKER_FILENAME |
| marker_path.write_text( |
| "This directory is generated by the VLAC2 public frame-extraction workflow.\n", |
| encoding="utf-8", |
| ) |
| return marker_path |
|
|
|
|
| def ensure_release_tree(release_root: Path) -> dict[str, Path]: |
| release_root = release_root.resolve() |
| paths = { |
| "release_root": release_root, |
| "raw_root": release_root / "data", |
| "benchmark_root": release_root / PUBLIC_BENCHMARK_DIRNAME, |
| "portable_image_root": release_root / PORTABLE_IMAGE_ROOT, |
| "scripts_root": release_root / "scripts", |
| } |
| for key in ("release_root", "raw_root", "benchmark_root", "scripts_root"): |
| paths[key].mkdir(parents=True, exist_ok=True) |
| return paths |
|
|
|
|
| def _normalized_parts(raw_path: str | Path) -> list[str]: |
| raw = str(raw_path or "").strip().replace("\\", "/") |
| if not raw: |
| raise ValueError("empty path") |
| return [part for part in Path(raw).parts if part not in ("", ".", "/")] |
|
|
|
|
| def dataset_relative_path(raw_path: str | Path) -> Path: |
| parts = _normalized_parts(raw_path) |
|
|
| for idx, part in enumerate(parts): |
| if part in KNOWN_DATASET_NAMES: |
| return Path(*parts[idx:]) |
|
|
| for portable_root in portable_image_roots(): |
| marker_parts = list(portable_root.parts) |
| marker_len = len(marker_parts) |
| for idx in range(max(0, len(parts) - marker_len + 1)): |
| if parts[idx : idx + marker_len] == marker_parts: |
| tail = parts[idx + marker_len :] |
| if not tail: |
| break |
| for tail_idx, part in enumerate(tail): |
| if part in KNOWN_DATASET_NAMES: |
| return Path(*tail[tail_idx:]) |
| return Path(*tail) |
|
|
| return Path(*parts) |
|
|
|
|
| def normalize_main_path(raw_main_path: str | Path) -> Path: |
| rel = dataset_relative_path(raw_main_path) |
| if rel.suffix.lower() in KNOWN_VIDEO_SUFFIXES: |
| return rel.with_suffix("") |
| return rel |
|
|
|
|
| def main_path_from_frame_path(raw_frame_path: str | Path) -> Path: |
| rel = dataset_relative_path(raw_frame_path) |
| if rel.suffix: |
| return rel.parent |
| return rel |
|
|
|
|
| def portable_frame_path_from_any(raw_frame_path: str | Path) -> Path: |
| return PORTABLE_IMAGE_ROOT / dataset_relative_path(raw_frame_path) |
|
|
|
|
| def placeholder_frame_path_from_any(raw_frame_path: str | Path) -> str: |
| return f"{PUBLIC_FRAMES_ROOT_PLACEHOLDER}/{dataset_relative_path(raw_frame_path).as_posix()}" |
|
|
|
|
| def absolute_frame_path_from_any(raw_frame_path: str | Path, frames_root: Path) -> Path: |
| raw = str(raw_frame_path or "").strip() |
| if not raw: |
| raise ValueError("empty frame path") |
| path = Path(raw) |
| if path.is_absolute(): |
| return path |
|
|
| parts = _normalized_parts(raw) |
| if parts and parts[0] in (PUBLIC_FRAMES_ROOT_PLACEHOLDER, PUBLIC_RELEASE_ROOT_PLACEHOLDER): |
| parts = parts[1:] |
|
|
| for portable_root in portable_image_roots(): |
| marker_parts = list(portable_root.parts) |
| if parts[: len(marker_parts)] == marker_parts: |
| return frames_root.resolve() / Path(*parts[len(marker_parts) :]) |
| if parts and parts[0] in KNOWN_DATASET_NAMES: |
| return frames_root.resolve() / Path(*parts) |
| return frames_root.resolve() / Path(*parts) |
|
|
|
|
| def rewrite_benchmark_image_paths( |
| rows: list[dict[str, Any]], |
| path_rewriter: Callable[[str], str], |
| ) -> list[dict[str, Any]]: |
| rewritten_rows: list[dict[str, Any]] = [] |
| for row in rows: |
| rewritten = dict(row) |
|
|
| frame_index = dict(row.get("frame_index") or {}) |
| if frame_index: |
| rewritten_frame_index: dict[str, dict[str, str]] = {} |
| for frame_idx, images in frame_index.items(): |
| image_map = dict(images or {}) |
| rewritten_frame_index[str(frame_idx)] = { |
| str(view): path_rewriter(str(image_path)) |
| for view, image_path in image_map.items() |
| if str(image_path or "").strip() |
| } |
| rewritten["frame_index"] = rewritten_frame_index |
|
|
| reference_context = row.get("reference_context") |
| if isinstance(reference_context, dict): |
| rewritten_ref = dict(reference_context) |
| anchors = list(reference_context.get("reference_anchors") or []) |
| rewritten_anchors: list[dict[str, Any]] = [] |
| for anchor in anchors: |
| rewritten_anchor = dict(anchor) |
| images = dict(anchor.get("images") or {}) |
| if images: |
| rewritten_anchor["images"] = { |
| str(view): path_rewriter(str(image_path)) |
| for view, image_path in images.items() |
| if str(image_path or "").strip() |
| } |
| rewritten_anchors.append(rewritten_anchor) |
| rewritten_ref["reference_anchors"] = rewritten_anchors |
| rewritten["reference_context"] = rewritten_ref |
|
|
| videos = row.get("videos") |
| if isinstance(videos, list): |
| rewritten_videos: list[Any] = [] |
| for item in videos: |
| if isinstance(item, list): |
| rewritten_videos.append( |
| [path_rewriter(str(path)) for path in item if str(path or "").strip()] |
| ) |
| elif isinstance(item, str) and item.strip(): |
| rewritten_videos.append(path_rewriter(item)) |
| rewritten["videos"] = rewritten_videos |
|
|
| images = row.get("images") |
| if isinstance(images, list): |
| rewritten["images"] = [ |
| path_rewriter(str(path)) |
| for path in images |
| if str(path or "").strip() |
| ] |
|
|
| rewritten_rows.append(rewritten) |
| return rewritten_rows |
|
|
|
|
| def infer_main_path_from_row(row: dict[str, Any]) -> Path | None: |
| for meta_key in ("metadata", "_meta", "meta"): |
| meta = row.get(meta_key) |
| if isinstance(meta, dict): |
| raw_main_path = str(meta.get("main_path") or "").strip() |
| if raw_main_path: |
| return normalize_main_path(raw_main_path) |
|
|
| frame_index = row.get("frame_index") |
| if isinstance(frame_index, dict): |
| for images in frame_index.values(): |
| if not isinstance(images, dict): |
| continue |
| for image_path in images.values(): |
| if str(image_path or "").strip(): |
| return main_path_from_frame_path(str(image_path)) |
|
|
| videos = row.get("videos") |
| if isinstance(videos, list) and videos: |
| first = videos[0] |
| if isinstance(first, list) and first: |
| return main_path_from_frame_path(str(first[0])) |
| if isinstance(first, str) and first.strip(): |
| return main_path_from_frame_path(first) |
|
|
| return None |
|
|
|
|
| def discover_benchmark_jsons(benchmark_root: Path) -> list[Path]: |
| benchmark_root = benchmark_root.resolve() |
| candidates: list[Path] = [] |
| seen: set[Path] = set() |
| for path in sorted(benchmark_root.glob(f"**/{PUBLIC_BENCHMARK_JSON_NAME}")): |
| resolved = path.resolve() |
| if resolved in seen: |
| continue |
| seen.add(resolved) |
| candidates.append(resolved) |
| return candidates |
|
|
|
|
| def resolve_benchmark_root(release_root: Path) -> Path: |
| release_root = release_root.resolve() |
| preferred = release_root / PUBLIC_BENCHMARK_DIRNAME |
| full_release = release_root / FULL_RELEASE_BENCHMARK_DIRNAME |
| legacy = release_root / LEGACY_BENCHMARK_DIRNAME |
| if preferred.exists(): |
| return preferred |
| if full_release.exists(): |
| return full_release |
| if legacy.exists(): |
| return legacy |
| return preferred |
|
|
