| |
| """Validate Real4D structure, frame counts, metadata, and image headers.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import struct |
| import sys |
| from pathlib import Path |
|
|
|
|
| EXPECTED = { |
| "dynerf": { |
| "resolution": (1352, 1014), |
| "scenes": { |
| "coffee_martini": 324, |
| "cook_spinach": 441, |
| "cut_roasted_beef": 400, |
| "flame_salmon": 361, |
| "flame_steak": 441, |
| "sear_steak": 441, |
| }, |
| }, |
| "meetroom": { |
| "resolution": (1280, 720), |
| "scenes": { |
| "discussion": 169, |
| "stepin": 169, |
| "trimming": 169, |
| "vrheadset": 169, |
| }, |
| }, |
| } |
|
|
| REQUIRED_CAMERA_FIELDS = { |
| "image_name", |
| "timestamp", |
| "w2c", |
| "R", |
| "T", |
| "FoVx", |
| "FoVy", |
| "fl_x", |
| "fl_y", |
| "cx", |
| "cy", |
| "width", |
| "height", |
| } |
|
|
|
|
| def child_dirs(path: Path) -> set[str]: |
| return {entry.name for entry in path.iterdir() if entry.is_dir()} |
|
|
|
|
| def json_stems(path: Path) -> set[str]: |
| return {entry.stem for entry in path.iterdir() if entry.is_file() and entry.suffix == ".json"} |
|
|
|
|
| def jpeg_size(path: Path) -> tuple[int, int]: |
| with path.open("rb") as handle: |
| if handle.read(2) != b"\xff\xd8": |
| raise ValueError("missing JPEG SOI marker") |
| while True: |
| byte = handle.read(1) |
| while byte == b"\xff": |
| byte = handle.read(1) |
| if not byte: |
| raise ValueError("JPEG size marker not found") |
| marker = byte[0] |
| if marker in (0xD8, 0xD9): |
| continue |
| length_raw = handle.read(2) |
| if len(length_raw) != 2: |
| raise ValueError("truncated JPEG segment") |
| length = struct.unpack(">H", length_raw)[0] |
| if marker in { |
| 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, |
| 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF, |
| }: |
| data = handle.read(5) |
| if len(data) != 5: |
| raise ValueError("truncated JPEG SOF segment") |
| height, width = struct.unpack(">HH", data[1:5]) |
| return width, height |
| handle.seek(length - 2, 1) |
|
|
|
|
| def png_info(path: Path) -> tuple[int, int, int, int]: |
| with path.open("rb") as handle: |
| header = handle.read(29) |
| if len(header) != 29 or header[:8] != b"\x89PNG\r\n\x1a\n" or header[12:16] != b"IHDR": |
| raise ValueError("invalid PNG header") |
| width, height, bit_depth, color_type = struct.unpack(">IIBB", header[16:26]) |
| return width, height, bit_depth, color_type |
|
|
|
|
| def shape_ok(value, rows: int, cols: int | None = None) -> bool: |
| if not isinstance(value, list) or len(value) != rows: |
| return False |
| if cols is None: |
| return True |
| return all(isinstance(row, list) and len(row) == cols for row in value) |
|
|
|
|
| def validate_trajectory( |
| scene_dir: Path, |
| trajectory: str, |
| resolution: tuple[int, int], |
| errors: list[str], |
| warnings: list[str], |
| ) -> None: |
| rgb_dir = scene_dir / "images" / trajectory |
| depth_dir = scene_dir / "depths" / trajectory |
| vis_dir = scene_dir / "depth_vis" / trajectory |
| rgb_pattern = re.compile(rf"^{re.escape(trajectory)}_(\d{{6}})\.jpg$") |
| depth_pattern = re.compile( |
| rf"^{re.escape(trajectory)}_(\d{{6}})\.jpg\.geometric\.png$" |
| ) |
|
|
| def numbered_files(path: Path, pattern: re.Pattern[str]) -> tuple[list[Path], list[int]]: |
| files = sorted(entry for entry in path.iterdir() if entry.is_file()) |
| numbers = [] |
| for entry in files: |
| match = pattern.match(entry.name) |
| if match: |
| numbers.append(int(match.group(1))) |
| return files, numbers |
|
|
| rgb_files, rgb_numbers = numbered_files(rgb_dir, rgb_pattern) |
| depth_files, depth_numbers = numbered_files(depth_dir, depth_pattern) |
| vis_files = sorted(entry for entry in vis_dir.iterdir() if entry.is_file()) |
|
|
| expected_numbers = list(range(1, 301)) |
| if len(rgb_files) != 300 or rgb_numbers != expected_numbers: |
| errors.append(f"{scene_dir}/{trajectory}: RGB numbering/count is not 000001..000300") |
| if len(depth_files) != 300 or depth_numbers != expected_numbers: |
| errors.append(f"{scene_dir}/{trajectory}: depth numbering/count is not 000001..000300") |
| if len(vis_files) != 300: |
| errors.append(f"{scene_dir}/{trajectory}: expected 300 depth previews, found {len(vis_files)}") |
|
|
| camera_path = scene_dir / "camera_params" / f"{trajectory}.json" |
| try: |
| with camera_path.open("r", encoding="utf-8") as handle: |
| records = json.load(handle) |
| except Exception as exc: |
| errors.append(f"{camera_path}: cannot parse JSON: {exc}") |
| return |
| if not isinstance(records, list) or len(records) != 300: |
| errors.append(f"{camera_path}: expected a 300-entry list") |
| return |
|
|
| timestamps = [] |
| image_names = set() |
| for index, record in enumerate(records): |
| missing = REQUIRED_CAMERA_FIELDS - set(record) |
| if missing: |
| errors.append(f"{camera_path}[{index}]: missing fields {sorted(missing)}") |
| break |
| timestamps.append(record["timestamp"]) |
| image_names.add(record["image_name"]) |
| if (record["width"], record["height"]) != resolution: |
| errors.append(f"{camera_path}[{index}]: unexpected resolution") |
| break |
| if not shape_ok(record["w2c"], 4, 4): |
| errors.append(f"{camera_path}[{index}]: w2c must be 4x4") |
| break |
| if not shape_ok(record["R"], 3, 3) or not shape_ok(record["T"], 3): |
| errors.append(f"{camera_path}[{index}]: invalid R or T shape") |
| break |
| if any(b <= a for a, b in zip(timestamps, timestamps[1:])): |
| errors.append(f"{camera_path}: timestamps are not strictly increasing") |
| if len(image_names) == 1: |
| warnings.append(f"{camera_path}: image_name is a constant source-camera identifier") |
|
|
| if rgb_files: |
| try: |
| if jpeg_size(rgb_files[0]) != resolution: |
| errors.append(f"{rgb_files[0]}: unexpected JPEG resolution") |
| except Exception as exc: |
| errors.append(f"{rgb_files[0]}: {exc}") |
| if depth_files: |
| try: |
| width, height, bit_depth, color_type = png_info(depth_files[0]) |
| if (width, height) != resolution or bit_depth != 16 or color_type != 0: |
| errors.append( |
| f"{depth_files[0]}: expected {resolution[0]}x{resolution[1]} " |
| "16-bit grayscale PNG" |
| ) |
| except Exception as exc: |
| errors.append(f"{depth_files[0]}: {exc}") |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("root", type=Path, help="Real4D dataset root") |
| parser.add_argument( |
| "--full", |
| action="store_true", |
| help="scan all 3,084 trajectories; default samples three per scene", |
| ) |
| args = parser.parse_args() |
| root = args.root.resolve() |
| errors: list[str] = [] |
| warnings: list[str] = [] |
| total_trajectories = 0 |
|
|
| for subset, subset_spec in EXPECTED.items(): |
| subset_dir = root / subset |
| expected_scenes = set(subset_spec["scenes"]) |
| if not subset_dir.is_dir(): |
| errors.append(f"missing subset directory: {subset_dir}") |
| continue |
| actual_scenes = child_dirs(subset_dir) |
| if actual_scenes != expected_scenes: |
| errors.append( |
| f"{subset}: scene mismatch; expected {sorted(expected_scenes)}, " |
| f"found {sorted(actual_scenes)}" |
| ) |
|
|
| for scene, expected_count in subset_spec["scenes"].items(): |
| scene_dir = subset_dir / scene |
| required_dirs = ("images", "depths", "depth_vis", "camera_params", "video") |
| missing_dirs = [name for name in required_dirs if not (scene_dir / name).is_dir()] |
| if missing_dirs: |
| errors.append(f"{scene_dir}: missing directories {missing_dirs}") |
| continue |
|
|
| image_trajectories = child_dirs(scene_dir / "images") |
| depth_trajectories = child_dirs(scene_dir / "depths") |
| vis_trajectories = child_dirs(scene_dir / "depth_vis") |
| camera_trajectories = json_stems(scene_dir / "camera_params") |
| total_trajectories += len(image_trajectories) |
|
|
| if len(image_trajectories) != expected_count: |
| errors.append( |
| f"{scene_dir}: expected {expected_count} trajectories, " |
| f"found {len(image_trajectories)}" |
| ) |
| for label, values in ( |
| ("depths", depth_trajectories), |
| ("depth_vis", vis_trajectories), |
| ("camera_params", camera_trajectories), |
| ): |
| if values != image_trajectories: |
| errors.append(f"{scene_dir}: {label} trajectory set differs from images") |
|
|
| videos = {entry.name for entry in (scene_dir / "video").iterdir() if entry.is_file()} |
| missing_videos = [ |
| filename |
| for trajectory in image_trajectories |
| for filename in (f"{trajectory}_rgb.mp4", f"{trajectory}_depth.mp4") |
| if filename not in videos |
| ] |
| if missing_videos: |
| errors.append( |
| f"{scene_dir}: missing {len(missing_videos)} release preview videos; " |
| f"first={missing_videos[0]}" |
| ) |
|
|
| ordered = sorted(image_trajectories) |
| selected = ordered if args.full else sorted({ordered[0], ordered[len(ordered) // 2], ordered[-1]}) |
| for trajectory in selected: |
| validate_trajectory( |
| scene_dir, |
| trajectory, |
| subset_spec["resolution"], |
| errors, |
| warnings, |
| ) |
| print( |
| f"checked {subset}/{scene}: {len(image_trajectories)} trajectories " |
| f"({len(selected)} deeply scanned)" |
| ) |
|
|
| if total_trajectories != 3084: |
| errors.append(f"expected 3,084 total trajectories, found {total_trajectories}") |
|
|
| if warnings: |
| print(f"\nNotes ({len(warnings)}):") |
| limit = len(warnings) if not args.full else min(10, len(warnings)) |
| for warning in warnings[:limit]: |
| print(f" - {warning}") |
| if len(warnings) > limit: |
| print(f" - ... {len(warnings) - limit} identical notes omitted") |
|
|
| if errors: |
| print(f"\nFAILED with {len(errors)} error(s):", file=sys.stderr) |
| for error in errors: |
| print(f" - {error}", file=sys.stderr) |
| return 1 |
|
|
| mode = "full" if args.full else "quick" |
| print(f"\nPASS: {mode} validation; {total_trajectories:,} trajectories found.") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
|
|
