Upload verify_top1000_delivery.py

MA_CARLA_top1000_quality_novel_weather_20260810/tools/verify_top1000_delivery.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""Deep structural validation for the selected MA-CARLA 1000-sequence delivery."""
+
+import argparse
+import concurrent.futures
+import csv
+import json
+import subprocess
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+
+CAMERAS = ("FRONT", "FRONT_LEFT", "FRONT_RIGHT", "REAR")
+FRAME_COUNT = 256
+WIDTH = 800
+HEIGHT = 600
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--selection-manifest", required=True)
+    parser.add_argument("--report", required=True)
+    parser.add_argument("--workers", type=int, default=12)
+    return parser.parse_args()
+
+
+def probe_video(path):
+    command = [
+        "ffprobe", "-v", "error", "-select_streams", "v:0",
+        "-show_entries", "stream=codec_name,pix_fmt,width,height,nb_frames",
+        "-of", "json", str(path),
+    ]
+    result = json.loads(subprocess.check_output(command, text=True))
+    streams = result.get("streams", [])
+    if len(streams) != 1:
+        raise RuntimeError("{} has {} video streams".format(path, len(streams)))
+    return streams[0]
+
+
+def validate_npz(path, agent_ids):
+    required_suffixes = {
+        "frame_index": (FRAME_COUNT,),
+        "carla_frame": (FRAME_COUNT,),
+        "timestamp": (FRAME_COUNT,),
+        "pose": (FRAME_COUNT, 6),
+        "camera_pose": (FRAME_COUNT, 6),
+        "all_camera_names": (4,),
+        "all_camera_pose": (FRAME_COUNT, 4, 6),
+        "all_camera_extrinsic": (FRAME_COUNT, 4, 4, 4),
+        "velocity": (FRAME_COUNT, 3),
+        "angular_velocity": (FRAME_COUNT, 3),
+        "acceleration": (FRAME_COUNT, 3),
+        "speed_mps": (FRAME_COUNT,),
+        "horizontal_speed_mps": (FRAME_COUNT,),
+        "control": (FRAME_COUNT, 7),
+        "other_agent_id": (FRAME_COUNT,),
+        "other_visible": (FRAME_COUNT,),
+        "other_bbox": (FRAME_COUNT, 4),
+    }
+    with np.load(str(path), allow_pickle=False) as arrays:
+        for agent_id in agent_ids:
+            for suffix, shape in required_suffixes.items():
+                key = "agent{}_{}".format(agent_id, suffix)
+                if key not in arrays:
+                    raise RuntimeError("missing NPZ key {}".format(key))
+                if arrays[key].shape != shape:
+                    raise RuntimeError("{} has shape {}, expected {}".format(key, arrays[key].shape, shape))
+            names = tuple(str(name) for name in arrays["agent{}_all_camera_names".format(agent_id)])
+            if names != CAMERAS:
+                raise RuntimeError("unexpected camera names for agent {}: {}".format(agent_id, names))
+
+
+def validate_csv(path, agent_ids):
+    required = {
+        "frame_index", "carla_frame", "timestamp", "agent_id", "image", "camera_name",
+        "vehicle_x", "vehicle_y", "vehicle_z", "vehicle_roll", "vehicle_pitch", "vehicle_yaw",
+        "camera_x", "camera_y", "camera_z", "camera_roll", "camera_pitch", "camera_yaw",
+        "all_camera_poses_json", "all_camera_extrinsics_json", "velocity_x", "velocity_y",
+        "velocity_z", "angular_velocity_x", "angular_velocity_y", "angular_velocity_z",
+        "acceleration_x", "acceleration_y", "acceleration_z", "speed_mps", "throttle", "steer",
+        "brake", "other_visible", "other_bbox_min_u", "other_bbox_min_v", "other_bbox_max_u",
+        "other_bbox_max_v",
+    }
+    counts = Counter()
+    frames = {agent_id: set() for agent_id in agent_ids}
+    with path.open(newline="") as file_obj:
+        reader = csv.DictReader(file_obj)
+        if not required.issubset(set(reader.fieldnames or [])):
+            raise RuntimeError("frames.csv missing columns: {}".format(sorted(required - set(reader.fieldnames or []))))
+        for row in reader:
+            agent_id = int(row["agent_id"])
+            counts[agent_id] += 1
+            frames.setdefault(agent_id, set()).add(int(row["frame_index"]))
+            if not row["all_camera_poses_json"] or not row["all_camera_extrinsics_json"]:
+                raise RuntimeError("empty all-camera pose/extrinsic field")
+    for agent_id in agent_ids:
+        if counts[agent_id] != FRAME_COUNT or frames[agent_id] != set(range(FRAME_COUNT)):
+            raise RuntimeError("agent {} has invalid CSV frame coverage".format(agent_id))
+
+
+def validate_record(record):
+    sequence = Path(record["source_sequence"])
+    metadata_path = sequence / "metadata" / "sequence.json"
+    csv_path = sequence / "annotations" / "frames.csv"
+    npz_path = sequence / "annotations" / "trajectory.npz"
+    videos_path = sequence / "videos" / "camera_videos.json"
+    for path in (metadata_path, csv_path, npz_path, videos_path):
+        if not path.is_file() or path.stat().st_size == 0:
+            raise RuntimeError("missing or empty {}".format(path))
+    metadata = json.loads(metadata_path.read_text())
+    if int(metadata.get("frames_per_sequence", 0)) != FRAME_COUNT:
+        raise RuntimeError("invalid metadata frame count")
+    agents = metadata.get("agents", [])
+    agent_ids = tuple(int(agent["agent_id"]) for agent in agents)
+    if agent_ids != (0, 1):
+        raise RuntimeError("unexpected agent ids {}".format(agent_ids))
+    cameras = metadata.get("cameras", [])
+    if tuple(camera.get("name") for camera in cameras) != CAMERAS:
+        raise RuntimeError("invalid camera rig")
+    for camera in cameras:
+        intrinsics = camera.get("intrinsics", {})
+        if int(intrinsics.get("width", 0)) != WIDTH or int(intrinsics.get("height", 0)) != HEIGHT:
+            raise RuntimeError("invalid camera intrinsics resolution")
+        if not all(key in intrinsics for key in ("fx", "fy", "cx", "cy", "fov")):
+            raise RuntimeError("incomplete camera intrinsics")
+        if not all(key in camera.get("transform", {}) for key in ("x", "y", "z", "roll", "pitch", "yaw")):
+            raise RuntimeError("incomplete camera transform")
+    replay = metadata.get("trajectory_replay")
+    if replay is None:
+        if record.get("quality_tier") != "legacy_kinematic":
+            raise RuntimeError("missing trajectory replay audit metadata")
+        replay_audit = "legacy_metadata_unavailable"
+    else:
+        if int(replay.get("captured_frames", 0)) != FRAME_COUNT or int(replay.get("collision_events", 0)) != 0:
+            raise RuntimeError("invalid replay frame or collision metadata")
+        replay_audit = "present_zero_collisions"
+
+    video_manifest = json.loads(videos_path.read_text())
+    streams = video_manifest.get("streams", [])
+    if len(streams) != len(agent_ids) * len(CAMERAS):
+        raise RuntimeError("invalid camera stream count")
+    expected_pairs = {("agent_{}".format(agent_id), camera) for agent_id in agent_ids for camera in CAMERAS}
+    actual_pairs = {(stream.get("agent"), stream.get("camera")) for stream in streams}
+    if actual_pairs != expected_pairs:
+        raise RuntimeError("invalid agent/camera stream set")
+    for stream in streams:
+        video = sequence / stream["path"]
+        if not video.is_file() or video.stat().st_size == 0:
+            raise RuntimeError("missing video {}".format(video))
+        probe = probe_video(video)
+        if int(probe.get("nb_frames", 0)) != FRAME_COUNT:
+            raise RuntimeError("{} has {} frames".format(video, probe.get("nb_frames")))
+        if int(probe["width"]) != WIDTH or int(probe["height"]) != HEIGHT:
+            raise RuntimeError("{} has invalid resolution".format(video))
+    validate_csv(csv_path, agent_ids)
+    validate_npz(npz_path, agent_ids)
+    return {
+        "package_id": record["package_id"],
+        "trajectory_index": record["trajectory_index"],
+        "weather": record["weather"],
+        "quality_tier": record["quality_tier"],
+        "video_streams": len(streams),
+        "frames_per_stream": FRAME_COUNT,
+        "replay_audit": replay_audit,
+        "status": "valid",
+    }
+
+
+def main():
+    args = parse_args()
+    manifest_path = Path(args.selection_manifest).resolve()
+    records = json.loads(manifest_path.read_text())
+    results = []
+    errors = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool:
+        futures = {pool.submit(validate_record, record): record for record in records}
+        for index, future in enumerate(concurrent.futures.as_completed(futures), 1):
+            record = futures[future]
+            try:
+                results.append(future.result())
+            except Exception as exc:
+                errors.append({"package_id": record.get("package_id"), "error": str(exc)})
+            if index % 25 == 0 or index == len(records):
+                print("validated {}/{} errors={}".format(index, len(records), len(errors)), flush=True)
+    report = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "selection_manifest": str(manifest_path),
+        "sequence_count": len(records),
+        "valid_count": len(results),
+        "error_count": len(errors),
+        "video_stream_count": sum(result["video_streams"] for result in results),
+        "decoded_frame_count": sum(result["video_streams"] * result["frames_per_stream"] for result in results),
+        "quality_tiers": dict(Counter(result["quality_tier"] for result in results)),
+        "replay_audit": dict(Counter(result["replay_audit"] for result in results)),
+        "checks": {
+            "agents_per_sequence": 2,
+            "cameras_per_agent": list(CAMERAS),
+            "frames_per_camera": FRAME_COUNT,
+            "resolution": [WIDTH, HEIGHT],
+            "zero_recorded_collisions_for_audited_renders": True,
+            "legacy_renders_without_replay_collision_audit": sum(
+                result["replay_audit"] == "legacy_metadata_unavailable" for result in results
+            ),
+            "camera_intrinsics_and_mounts": True,
+            "per_frame_camera_poses_and_extrinsics": True,
+            "vehicle_pose_velocity_acceleration_controls": True,
+            "visibility_and_bounding_boxes": True,
+        },
+        "errors": errors,
+    }
+    report_path = Path(args.report).resolve()
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    print(json.dumps(report, indent=2, sort_keys=True))
+    if errors:
+        raise SystemExit("delivery verification failed")
+
+
+if __name__ == "__main__":
+    main()