Add Real4D metadata: scripts/validate_dataset.py

scripts/validate_dataset.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""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())
+