Blame for OVOW/benchmark/scripts/run_big_eval.py

#!/usr/bin/env python3


from __future__ import annotations

import argparse
import hashlib
import importlib.util
import json
import pickle
import re
import subprocess
import tempfile
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable

import cv2
import numpy as np
from PIL import Image
from scipy.optimize import linear_sum_assignment


SCENE_EXTS = (".blend", ".glb", ".gltf")
IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".webp", ".bmp")
DEPTH_NAMES = ("depth.npy", "depth.npz", "depth.png", "depth.exr")
CAMERA_NAMES = (
    "camera.json",
    "cameras.json",
    "poses.json",
    "camera_poses.json",
    "transforms.json",
    "extrinsics.npy",
    "extrinsics.npz",
    "poses.npy",
    "poses.npz",
    "cameras.npz",
)
EPS = 1e-9
OBJECT_NAME_STOPWORDS = {
    "object",
    "geometry",
    "mesh",
    "model",
    "shape",
    "textured",
    "scene",
    "gt",
    "pred",
}


def lower_is_better_to_score(value: float, bad_value: float = 1.0) -> float:
    if bad_value <= 0:
        raise ValueError("bad_value must be > 0")
    normalized = max(0.0, min(1.0, value / bad_value))
    return 100.0 * (1.0 - normalized)


@dataclass(frozen=True)
class AssetBundle:
    key: str
    base: Path
    scene: Path
    images: tuple[Path, ...]
    text: Path | None
    depth: Path | None
    camera: Path | None
    generated_meta: Path | None


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Run full eval for one sample id across multiple models")
    p.add_argument("--sample_id", required=True)
    p.add_argument("--data_root", default="data")
    p.add_argument("--gt_key", default="gt")
    p.add_argument(
        "--models",
        required=True,
        help="Comma-separated model keys under data_root",
    )
    p.add_argument("--blender_bin", required=True)
    p.add_argument("--clip_model_path", required=True)
    p.add_argument("--clip_batch_size", type=int, default=32)
    p.add_argument("--out_json", required=True)
    p.add_argument(
        "--alignment",
        choices=["identity", "bbox", "object_bbox", "depth_bbox", "depth_camera"],
        default="bbox",
        help=(
            "Transform pred geometry into GT coordinates before IoU. "
            "object_bbox anchors on the best first-frame object IoU match; "
            "depth_camera uses depth median scale plus first-camera canonicalization."
        ),
    )
    p.add_argument(
        "--ground_policy",
        choices=["exclude", "include"],
        default="exclude",
        help=(
            "Whether to exclude detected ground/floor/large planes from bbox alignment "
            "and scene/object IoU. Use include to benchmark with ground from alignment onward."
        ),
    )
    p.add_argument(
        "--camera_convention",
        choices=["auto", "world_to_camera", "camera_to_world"],
        default="auto",
        help="Convention for camera matrices used by --alignment depth_camera.",
    )
    p.add_argument(
        "--camera_rotation_only",
        action="store_true",
        help="For --alignment depth_camera, use only first-frame camera rotation and ignore camera translation.",
    )
    p.add_argument(
        "--auto_scene_meta",
        action=argparse.BooleanOptionalAction,
        default=True,
        help="Auto-extract camera.json/depth.npy from scene.blend/glb when missing.",
    )
    p.add_argument(
        "--scene_meta_dir",
        default=None,
        help="Cache directory for auto-extracted scene camera/depth metadata.",
    )
    p.add_argument(
        "--alignment_dir",
        default=None,
        help="Directory for per-model alignment_transform.json files (default: out_json parent/alignments)",
    )
    p.add_argument(
        "--geometry_frame_mode",
        default="first_mid_last",
        help="Geometry frames used for IoU-B extraction: first_only, first_mid_last, last_only, or exact:<frame>.",
    )
    p.add_argument(
        "--image_glob",
        default="frames/*,selected_frames/*,eval_frames/*,scene.png",
        help="Comma-separated image globs relative to each asset directory",
    )
    p.add_argument(
        "--scene_filename",
        default=None,
        help="Optional fixed scene filename, e.g. scene.glb. Otherwise auto-detect scene.*",
    )
    p.add_argument(
        "--allow_missing_images",
        action="store_true",
        help="Skip PL/N-CLIP for models without selected images instead of failing",
    )
    p.add_argument(
        "--skip_selected_image_metrics",
        action="store_true",
        help="Skip selected-frame PL/N-CLIP in this stage. Useful when rendered metrics are computed later.",
    )
    args = p.parse_args()
    _validate_frame_mode(args.geometry_frame_mode)
    return args


def _validate_frame_mode(mode: str) -> None:
    if mode in {"first_only", "first_mid_last", "last_only"}:
        return
    if mode.startswith("exact:"):
        raw = mode.split(":", 1)[1].strip()
        if raw and raw.lstrip("-").isdigit():
            return
    raise ValueError(
        f"Unsupported --geometry_frame_mode {mode!r}; expected first_only, "
        "first_mid_last, last_only, or exact:<frame>."
    )


def _project_root() -> Path:
    return Path(__file__).resolve().parents[1]


def _resolve_data_root(project_root: Path, raw: str) -> Path:
    path = Path(raw)
    if path.is_absolute():
        return path
    return (project_root / path).resolve()


def _first_existing(paths: Iterable[Path]) -> Path | None:
    for path in paths:
        if path.exists():
            return path
    return None


def _find_scene(base: Path, scene_filename: str | None) -> Path:
    if scene_filename:
        scene = base / scene_filename
        if scene.exists():
            return scene
        raise FileNotFoundError(f"Missing scene asset: {scene}")

    for ext in SCENE_EXTS:
        scene = base / f"scene{ext}"
        if scene.exists():
            return scene

    candidates: list[Path] = []
    for ext in SCENE_EXTS:
        candidates.extend(sorted(base.glob(f"*{ext}")))
    if candidates:
        return candidates[0]
    raise FileNotFoundError(f"No scene asset found under {base} ({', '.join(SCENE_EXTS)})")


def _find_images(base: Path, image_glob: str) -> tuple[Path, ...]:
    out: list[Path] = []
    seen: set[Path] = set()
    patterns = [x.strip() for x in image_glob.split(",") if x.strip()]
    for pattern in patterns:
        for path in sorted(base.glob(pattern)):
            if not path.is_file():
                continue
            if path.suffix.lower() not in IMAGE_EXTS:
                continue
            resolved = path.resolve()
            if resolved in seen:
                continue
            seen.add(resolved)
            out.append(resolved)
    return tuple(out)


def _find_depth(base: Path) -> Path | None:
    direct = _first_existing(base / name for name in DEPTH_NAMES)
    if direct is not None:
        return direct
    depth_dir = base / "depth"
    if depth_dir.is_dir():
        for ext in (".npy", ".npz", ".png", ".exr"):
            cands = sorted(depth_dir.glob(f"*{ext}"))
            if cands:
                return cands[0]
    return None


def _find_camera(base: Path) -> Path | None:
    direct = _first_existing(base / name for name in CAMERA_NAMES)
    if direct is not None:
        return direct
    camera_dir = base / "camera"
    if camera_dir.is_dir():
        for name in CAMERA_NAMES:
            candidate = camera_dir / name
            if candidate.exists():
                return candidate
        for pattern in ("*.json", "*.npy", "*.npz", "*.txt"):
            cands = sorted(camera_dir.glob(pattern))
            if cands:
                return cands[0]
    cameras_dir = base / "cameras"
    if cameras_dir.is_dir():
        for pattern in ("*.json", "*.npy", "*.npz", "*.txt"):
            cands = sorted(cameras_dir.glob(pattern))
            if cands:
                return cands[0]
    return None


def _scene_meta_script_path(project_root: Path) -> Path:
    script = project_root / "scripts" / "extract_scene_camera_depth.py"
    if not script.exists():
        raise FileNotFoundError(f"Missing scene meta extraction script: {script}")
    return script


def _scene_meta_cache_dir(root: Path, asset: AssetBundle) -> Path:
    stat = asset.scene.stat()
    key = f"{asset.scene.resolve()}::{stat.st_mtime_ns}::scene_meta_v1"
    digest = hashlib.sha256(key.encode("utf-8")).hexdigest()[:12]
    return root / asset.key / asset.scene.stem / digest


def ensure_scene_meta(
    asset: AssetBundle,
    *,
    project_root: Path,
    blender_bin: str,
    scene_meta_dir: Path,
    force: bool = False,
) -> AssetBundle:
    if asset.depth is not None and asset.camera is not None:
        return asset

    out_dir = _scene_meta_cache_dir(scene_meta_dir, asset)
    camera_path = out_dir / "camera.json"
    depth_path = out_dir / "depth.npy"
    if force or not camera_path.exists() or not depth_path.exists():
        out_dir.mkdir(parents=True, exist_ok=True)
        cmd = [
            blender_bin,
            "--factory-startup",
            "--background",
            "--python",
            str(_scene_meta_script_path(project_root)),
            "--",
            "--input",
            str(asset.scene),
            "--output_dir",
            str(out_dir),
        ]
        proc = subprocess.run(cmd, capture_output=True, text=True)
        if proc.returncode != 0 or not camera_path.exists() or not depth_path.exists():
            raise RuntimeError(
                "Scene camera/depth metadata extraction failed\n"
                f"scene={asset.scene}\n"
                f"code={proc.returncode}\n"
                f"stdout_tail={proc.stdout[-1000:]}\n"
                f"stderr_tail={proc.stderr[-1000:]}"
            )

    return AssetBundle(
        key=asset.key,
        base=asset.base,
        scene=asset.scene,
        images=asset.images,
        text=asset.text,
        depth=asset.depth or depth_path,
        camera=asset.camera or camera_path,
        generated_meta=out_dir,
    )


def load_assets(
    data_root: Path,
    model_key: str,
    sample_id: str,
    *,
    image_glob: str,
    scene_filename: str | None,
) -> AssetBundle:
    base = data_root / model_key / sample_id
    scene = _find_scene(base, scene_filename)
    text = _first_existing([base / "description.txt", base / "prompt.txt", base / "text.txt"])
    return AssetBundle(
        key=model_key,
        base=base,
        scene=scene.resolve(),
        images=_find_images(base, image_glob),
        text=text.resolve() if text is not None else None,
        depth=_find_depth(base),
        camera=_find_camera(base),
        generated_meta=None,
    )


def import_bbox_helpers(project_root: Path):
    bbox_script = project_root / "scripts" / "eval_bbox_iou_blend.py"
    spec = importlib.util.spec_from_file_location("eval_bbox_iou_blend", bbox_script)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"Unable to import {bbox_script}")
    mod = importlib.util.module_from_spec(spec)
    import sys

    sys.modules[spec.name] = mod
    spec.loader.exec_module(mod)
    return mod


def run_extract(
    blender_bin: str,
    extract_script: Path,
    scene_path: Path,
    out_path: Path,
    *,
    frame_mode: str,
) -> None:
    cmd = [
        blender_bin,
        "--factory-startup",
        "--background",
        "--python",
        str(extract_script),
        "--",
        "--input",
        str(scene_path),
        "--output",
        str(out_path),
        "--frame_mode",
        frame_mode,
    ]
    proc = subprocess.run(cmd, capture_output=True, text=True)
    if proc.returncode != 0 or not out_path.exists():
        raise RuntimeError(
            "Scene extraction failed\n"
            f"scene={scene_path}\n"
            f"code={proc.returncode}\n"
            f"stdout_tail={proc.stdout[-1000:]}\n"
            f"stderr_tail={proc.stderr[-1000:]}"
        )


def _load_payload(
    scene_path: Path,
    *,
    blender_bin: str,
    extract_script: Path,
    frame_mode: str,
    payload_cache: dict[str, dict[str, Any]],
) -> dict[str, Any]:
    k = f"{scene_path.resolve()}::{frame_mode}"
    if k in payload_cache:
        return payload_cache[k]
    with tempfile.TemporaryDirectory(prefix="big_eval_extract_") as td:
        p = Path(td) / "mesh.pkl"
        run_extract(blender_bin, extract_script, scene_path, p, frame_mode=frame_mode)
        payload = pickle.loads(p.read_bytes())
        payload_cache[k] = payload
        return payload


def _aligned_indices(total: int, target: int) -> list[int]:
    if total <= 0 or target <= 0:
        return []
    if target >= total:
        return list(range(total))
    return np.linspace(0, total - 1, num=target, dtype=int).tolist()


def _stack_frame_vertices(bbox_mod: Any, frame: dict[str, Any]) -> np.ndarray:
    return bbox_mod._stack_vertices(bbox_mod._to_mesh_map(frame))


_GROUND_NAME_TOKENS = ("ground", "floor", "plane", "table_plane", "backdrop", "wall")


def _is_ground_object(name: str, vertices: np.ndarray, scene_diag: float) -> bool:
    low = name.lower()
    if any(tok in low for tok in _GROUND_NAME_TOKENS):
        return True
    if vertices.size == 0:
        return False
    ext = vertices.max(axis=0) - vertices.min(axis=0)
    xy = float(np.hypot(ext[0], ext[1]))
    z = float(ext[2])

    if scene_diag > 0 and xy >= 0.55 * scene_diag and z <= 0.06 * max(xy, EPS):
        return True
    return False


def _stack_frame_vertices_no_ground(bbox_mod: Any, frame: dict[str, Any]) -> np.ndarray:
    mesh_map = bbox_mod._to_mesh_map(frame)
    full = bbox_mod._stack_vertices(mesh_map)
    if full.size == 0:
        return full
    scene_diag = float(np.linalg.norm(full.max(axis=0) - full.min(axis=0)))
    kept = {
        name: md
        for name, md in mesh_map.items()
        if not _is_ground_object(name, md.vertices, scene_diag)
    }
    if not kept:
        return full
    stacked = bbox_mod._stack_vertices(kept)
    return stacked if stacked.size else full


def _drop_ground_from_map(mesh_map: dict[str, Any]) -> dict[str, Any]:
    if not mesh_map:
        return mesh_map
    full = _stack_mesh_map_safe(mesh_map)
    scene_diag = float(np.linalg.norm(full.max(axis=0) - full.min(axis=0))) if full.size else 0.0
    kept = {
        name: md
        for name, md in mesh_map.items()
        if not _is_ground_object(name, md.vertices, scene_diag)
    }
    return kept if kept else mesh_map


def _stack_mesh_map_safe(mesh_map: dict[str, Any]) -> np.ndarray:
    chunks = [md.vertices for md in mesh_map.values() if getattr(md, "vertices", None) is not None and md.vertices.size]
    if not chunks:
        return np.zeros((0, 3), dtype=np.float64)
    return np.concatenate(chunks, axis=0)


def _aabb_bounds(vertices: np.ndarray) -> tuple[np.ndarray, np.ndarray] | None:
    if vertices.size == 0:
        return None
    return np.min(vertices, axis=0), np.max(vertices, axis=0)


def _center(bounds: tuple[np.ndarray, np.ndarray] | None) -> np.ndarray:
    if bounds is None:
        return np.zeros(3, dtype=np.float64)
    return 0.5 * (bounds[0] + bounds[1])


def _diag(bounds: tuple[np.ndarray, np.ndarray] | None) -> float:
    if bounds is None:
        return 1.0
    return float(np.linalg.norm(bounds[1] - bounds[0]))


def _first_frame_mesh_map(bbox_mod: Any, payload: dict[str, Any]) -> dict[str, Any]:
    frame = payload["objects_per_frame"][0] if payload.get("objects_per_frame") else {}
    return bbox_mod._to_mesh_map(frame)


def _name_tokens(name: str) -> set[str]:
    tokens = set(re.findall(r"[a-zA-Z]+", name.lower()))
    return {tok for tok in tokens if tok not in OBJECT_NAME_STOPWORDS and len(tok) > 1}


def _best_object_anchor_bounds(
    bbox_mod: Any,
    gt_payload: dict[str, Any],
    pred_payload: dict[str, Any],
) -> tuple[tuple[np.ndarray, np.ndarray] | None, tuple[np.ndarray, np.ndarray] | None, dict[str, Any] | None]:
    gt_map = _first_frame_mesh_map(bbox_mod, gt_payload)
    pred_map = _first_frame_mesh_map(bbox_mod, pred_payload)
    best: tuple[tuple[int, float], str, str, float, tuple[np.ndarray, np.ndarray], tuple[np.ndarray, np.ndarray]] | None = None
    for gt_name, gt_mesh in gt_map.items():
        gt_bounds = _aabb_bounds(gt_mesh.vertices)
        if gt_bounds is None:
            continue
        gt_tokens = _name_tokens(gt_name)
        for pred_name, pred_mesh in pred_map.items():
            pred_bounds = _aabb_bounds(pred_mesh.vertices)
            if pred_bounds is None:
                continue
            aabb, obb = _bbox_iou_for_meshes(bbox_mod, gt_mesh.vertices, pred_mesh.vertices)
            token_overlap = len(gt_tokens & _name_tokens(pred_name))
            score = (token_overlap, float(aabb))
            if best is None or score > best[0]:
                best = (score, gt_name, pred_name, float(obb), gt_bounds, pred_bounds)
    if best is None:
        return None, None, None
    score, gt_name, pred_name, obb, gt_bounds, pred_bounds = best
    return gt_bounds, pred_bounds, {
        "gt_name": gt_name,
        "pred_name": pred_name,
        "name_token_overlap": score[0],
        "first_frame_aabb_iou_before_alignment": score[1],
        "first_frame_obb_iou_before_alignment": obb,
    }


def _read_depth_values(depth_path: Path | None) -> np.ndarray:
    if depth_path is None or not depth_path.exists():
        return np.zeros((0,), dtype=np.float64)
    ext = depth_path.suffix.lower()
    if ext == ".npy":
        arr = np.load(depth_path)
    elif ext == ".npz":
        data = np.load(depth_path)
        key = "depth" if "depth" in data else data.files[0]
        arr = data[key]
    else:
        arr = cv2.imread(str(depth_path), cv2.IMREAD_UNCHANGED)
        if arr is None:
            return np.zeros((0,), dtype=np.float64)
        if arr.dtype == np.uint16:
            arr = arr.astype(np.float32) / 1000.0
    arr = np.asarray(arr, dtype=np.float64)
    vals = arr[np.isfinite(arr) & (arr > 1e-8)]
    return vals.reshape(-1)


def _depth_median(depth_path: Path | None) -> float | None:
    vals = _read_depth_values(depth_path)
    if vals.size == 0:
        return None
    return float(np.median(vals))


def _as_4x4(matrix_like: Any) -> np.ndarray | None:
    arr = np.asarray(matrix_like, dtype=np.float64)
    if arr.shape == (4, 4):
        return arr
    if arr.shape == (3, 4):
        out = np.eye(4, dtype=np.float64)
        out[:3, :4] = arr
        return out
    if arr.ndim == 3 and arr.shape[-2:] == (4, 4) and arr.shape[0] > 0:
        return arr[0]
    if arr.ndim == 3 and arr.shape[-2:] == (3, 4) and arr.shape[0] > 0:
        out = np.eye(4, dtype=np.float64)
        out[:3, :4] = arr[0]
        return out
    return None


def _matrix_from_json_obj(obj: Any) -> tuple[np.ndarray | None, str | None]:
    if isinstance(obj, list):
        matrix = _as_4x4(obj)
        if matrix is not None:
            return matrix, None
        if obj:
            return _matrix_from_json_obj(obj[0])

    if not isinstance(obj, dict):
        return None, None

    for key in ("world_to_camera", "w2c", "extrinsic", "extrinsics", "T_world_to_camera"):
        if key in obj:
            matrix = _as_4x4(obj[key])
            if matrix is not None:
                return matrix, "world_to_camera"

    for key in ("camera_to_world", "c2w", "pose", "poses", "transform_matrix", "T_camera_to_world"):
        if key in obj:
            matrix = _as_4x4(obj[key])
            if matrix is not None:
                return matrix, "camera_to_world"

    for key in ("frames", "cameras"):
        value = obj.get(key)
        if isinstance(value, list) and value:
            return _matrix_from_json_obj(value[0])

    numeric_values = [v for v in obj.values() if isinstance(v, (list, tuple, dict))]
    for value in numeric_values:
        matrix, convention = _matrix_from_json_obj(value)
        if matrix is not None:
            return matrix, convention

    return None, None


def _load_camera_matrix(camera_path: Path | None) -> tuple[np.ndarray | None, str | None]:
    if camera_path is None or not camera_path.exists():
        return None, None

    ext = camera_path.suffix.lower()
    if ext == ".json":
        data = json.loads(camera_path.read_text(encoding="utf-8"))
        return _matrix_from_json_obj(data)
    if ext == ".npy":
        return _as_4x4(np.load(camera_path)), None
    if ext == ".npz":
        data = np.load(camera_path)
        priority = (
            "world_to_camera",
            "w2c",
            "extrinsics",
            "extrinsic",
            "camera_to_world",
            "c2w",
            "poses",
            "pose",
        )
        for key in priority:
            if key in data:
                matrix = _as_4x4(data[key])
                if matrix is not None:
                    if key in {"world_to_camera", "w2c", "extrinsics", "extrinsic"}:
                        return matrix, "world_to_camera"
                    if key in {"camera_to_world", "c2w", "poses", "pose"}:
                        return matrix, "camera_to_world"
        for key in data.files:
            matrix = _as_4x4(data[key])
            if matrix is not None:
                return matrix, None
    if ext == ".txt":
        arr = np.loadtxt(camera_path)
        return _as_4x4(arr), None
    return None, None


def _orthonormalize_rotation(rot: np.ndarray) -> np.ndarray:
    u, _, vt = np.linalg.svd(rot)
    out = u @ vt
    if np.linalg.det(out) < 0:
        u[:, -1] *= -1.0
        out = u @ vt
    return out


def _camera_world_to_camera(
    camera_path: Path | None,
    *,
    convention: str,
) -> tuple[np.ndarray | None, str | None]:
    matrix, inferred = _load_camera_matrix(camera_path)
    if matrix is None:
        return None, None

    use_convention = inferred if convention == "auto" else convention
    if use_convention is None:
        use_convention = "world_to_camera"

    matrix = np.asarray(matrix, dtype=np.float64)
    if use_convention == "camera_to_world":
        matrix = np.linalg.inv(matrix)
    elif use_convention != "world_to_camera":
        raise ValueError(f"Unsupported camera convention: {use_convention}")

    matrix[:3, :3] = _orthonormalize_rotation(matrix[:3, :3])
    return matrix, use_convention


def _camera_canonical_matrix(
    camera_path: Path | None,
    *,
    convention: str,
    rotation_only: bool,
) -> tuple[np.ndarray | None, str | None]:
    w2c, used_convention = _camera_world_to_camera(camera_path, convention=convention)
    if w2c is None:
        return None, None
    matrix = np.eye(4, dtype=np.float64)
    matrix[:3, :3] = w2c[:3, :3]
    if not rotation_only:
        matrix[:3, 3] = w2c[:3, 3]
    return matrix, used_convention


def _compose_similarity(
    canonical: np.ndarray,
    scale: float,
    *,
    center_after: np.ndarray | None = None,
) -> np.ndarray:
    matrix = canonical.copy()
    matrix[:3, :3] *= float(scale)
    matrix[:3, 3] *= float(scale)
    if center_after is not None:
        matrix[:3, 3] += center_after
    return matrix


def build_alignment_transform(
    gt_payload: dict[str, Any],
    pred_payload: dict[str, Any],
    *,
    gt_depth: Path | None,
    pred_depth: Path | None,
    gt_camera: Path | None = None,
    pred_camera: Path | None = None,
    mode: str,
    bbox_mod: Any,
    camera_convention: str = "auto",
    camera_rotation_only: bool = False,
    ground_policy: str = "exclude",
) -> dict[str, Any]:
    gt_frame = gt_payload["objects_per_frame"][0] if gt_payload["objects_per_frame"] else {}
    pred_frame = pred_payload["objects_per_frame"][0] if pred_payload["objects_per_frame"] else {}
    gt_vertices = _stack_frame_vertices(bbox_mod, gt_frame)
    pred_vertices = _stack_frame_vertices(bbox_mod, pred_frame)
    gt_bounds = _aabb_bounds(gt_vertices)
    pred_bounds = _aabb_bounds(pred_vertices)

    scale = 1.0
    scale_source = "identity"
    gt_matrix = np.eye(4, dtype=np.float64)
    pred_matrix = np.eye(4, dtype=np.float64)
    gt_camera_convention = None
    pred_camera_convention = None
    uses_camera = False
    alignment_anchor: dict[str, Any] | None = None

    if mode == "bbox":
        if ground_policy == "exclude":


            gt_align_bounds = _aabb_bounds(_stack_frame_vertices_no_ground(bbox_mod, gt_frame))
            pred_align_bounds = _aabb_bounds(_stack_frame_vertices_no_ground(bbox_mod, pred_frame))
            if gt_align_bounds is not None:
                gt_bounds = gt_align_bounds
            if pred_align_bounds is not None:
                pred_bounds = pred_align_bounds
            scale_source = "scene_bbox_diag_no_ground"
        else:
            scale_source = "scene_bbox_diag_with_ground"
        scale = _diag(gt_bounds) / max(_diag(pred_bounds), EPS)
    elif mode == "object_bbox":
        anchor_gt_bounds, anchor_pred_bounds, alignment_anchor = _best_object_anchor_bounds(
            bbox_mod,
            gt_payload,
            pred_payload,
        )
        if anchor_gt_bounds is not None and anchor_pred_bounds is not None:
            gt_bounds = anchor_gt_bounds
            pred_bounds = anchor_pred_bounds
            scale = _diag(gt_bounds) / max(_diag(pred_bounds), EPS)
            scale_source = "best_object_bbox_diag"
        else:
            scale = _diag(gt_bounds) / max(_diag(pred_bounds), EPS)
            scale_source = "scene_bbox_diag_fallback_no_object_anchor"
    elif mode == "depth_bbox":
        gt_med = _depth_median(gt_depth)
        pred_med = _depth_median(pred_depth)
        if gt_med is not None and pred_med is not None:
            scale = gt_med / max(pred_med, EPS)
            scale_source = "depth_median_ratio"
        else:
            scale = _diag(gt_bounds) / max(_diag(pred_bounds), EPS)
            scale_source = "scene_bbox_diag_fallback"
    elif mode == "identity":
        scale = 1.0
    elif mode == "depth_camera":
        gt_med = _depth_median(gt_depth)
        pred_med = _depth_median(pred_depth)
        if gt_med is not None and pred_med is not None:
            scale = gt_med / max(pred_med, EPS)
            scale_source = "depth_median_ratio"
        else:
            scale = _diag(gt_bounds) / max(_diag(pred_bounds), EPS)
            scale_source = "scene_bbox_diag_fallback_no_depth"

        gt_canon, gt_camera_convention = _camera_canonical_matrix(
            gt_camera,
            convention=camera_convention,
            rotation_only=camera_rotation_only,
        )
        pred_canon, pred_camera_convention = _camera_canonical_matrix(
            pred_camera,
            convention=camera_convention,
            rotation_only=camera_rotation_only,
        )
        if gt_canon is None or pred_canon is None:
            raise FileNotFoundError(
                "depth_camera alignment requires readable first-frame camera matrices for both GT and Pred. "
                f"gt_camera={gt_camera} pred_camera={pred_camera}"
            )




        gt_matrix = gt_canon
        pred_matrix = _compose_similarity(pred_canon, scale)
        uses_camera = True
    else:
        raise ValueError(f"Unsupported alignment mode: {mode}")

    if not uses_camera:
        gt_center = _center(gt_bounds)
        pred_center = _center(pred_bounds)
        translation = gt_center - scale * pred_center
        pred_matrix = np.eye(4, dtype=np.float64)
        pred_matrix[:3, :3] *= scale
        pred_matrix[:3, 3] = translation
        if mode == "identity":
            pred_matrix[:3, 3] = 0.0

    return {
        "mode": mode,
        "transform_direction": "gt_to_eval_and_pred_to_eval",
        "matrix": pred_matrix.tolist(),
        "gt_matrix": gt_matrix.tolist(),
        "pred_matrix": pred_matrix.tolist(),
        "scale": float(scale),
        "translation": pred_matrix[:3, 3].astype(float).tolist(),
        "rotation": pred_matrix[:3, :3].astype(float).tolist(),
        "scale_source": scale_source,
        "gt_depth": str(gt_depth) if gt_depth else None,
        "pred_depth": str(pred_depth) if pred_depth else None,
        "gt_camera": str(gt_camera) if gt_camera else None,
        "pred_camera": str(pred_camera) if pred_camera else None,
        "camera_convention": camera_convention,
        "gt_camera_convention_used": gt_camera_convention,
        "pred_camera_convention_used": pred_camera_convention,
        "camera_rotation_only": bool(camera_rotation_only),
        "ground_policy": ground_policy,
        "alignment_anchor": alignment_anchor,
        "note": (
            "This transform is generated before geometry metrics. depth_camera maps "
            "GT and Pred into first-camera canonical coordinates and applies depth "
            "median scale to Pred; bbox/depth_bbox/object_bbox keep pred-to-GT "
            "uniform scale + translation behavior."
        ),
    }


def _transform_vertices(vertices: np.ndarray, matrix: np.ndarray) -> np.ndarray:
    if vertices.size == 0:
        return vertices.astype(np.float64, copy=False)
    rot_scale = matrix[:3, :3]
    trans = matrix[:3, 3]
    return (vertices.astype(np.float64) @ rot_scale.T + trans).astype(np.float64, copy=False)


def _transformed_mesh_map(bbox_mod: Any, raw_frame: dict[str, Any], matrix: np.ndarray) -> dict[str, Any]:
    mesh_map = bbox_mod._to_mesh_map(raw_frame)
    for mesh in mesh_map.values():
        mesh.vertices = _transform_vertices(mesh.vertices, matrix)
    return mesh_map


def _bbox_iou_for_meshes(bbox_mod: Any, gt_vertices: np.ndarray, pred_vertices: np.ndarray) -> tuple[float, float]:
    aabb = bbox_mod._aabb_iou(
        bbox_mod._aabb_from_vertices(gt_vertices),
        bbox_mod._aabb_from_vertices(pred_vertices),
    )
    obb = bbox_mod._obb_iou(
        bbox_mod._obb_from_vertices(gt_vertices),
        bbox_mod._obb_from_vertices(pred_vertices),
    )
    return float(aabb), float(obb)


def _match_objects_by_iou(
    bbox_mod: Any,
    gt_map: dict[str, Any],
    pred_map: dict[str, Any],
) -> dict[str, Any]:
    gt_names = sorted(gt_map.keys())
    pred_names = sorted(pred_map.keys())
    if not gt_names and not pred_names:
        return {
            "aabb_penalized": 1.0,
            "obb_penalized": 1.0,
            "aabb_matched_mean": 1.0,
            "obb_matched_mean": 1.0,
            "matches": [],
            "unmatched_gt": [],
            "unmatched_pred": [],
        }
    if not gt_names or not pred_names:
        return {
            "aabb_penalized": 0.0,
            "obb_penalized": 0.0,
            "aabb_matched_mean": 0.0,
            "obb_matched_mean": 0.0,
            "matches": [],
            "unmatched_gt": gt_names,
            "unmatched_pred": pred_names,
        }

    aabb_matrix = np.zeros((len(gt_names), len(pred_names)), dtype=np.float64)
    obb_matrix = np.zeros_like(aabb_matrix)
    for gi, gt_name in enumerate(gt_names):
        for pi, pred_name in enumerate(pred_names):
            aabb, obb = _bbox_iou_for_meshes(
                bbox_mod,
                gt_map[gt_name].vertices,
                pred_map[pred_name].vertices,
            )
            aabb_matrix[gi, pi] = aabb
            obb_matrix[gi, pi] = obb

    rows, cols = linear_sum_assignment(-aabb_matrix)
    matches: list[dict[str, Any]] = []
    matched_aabb: list[float] = []
    matched_obb: list[float] = []
    used_gt: set[str] = set()
    used_pred: set[str] = set()
    for row, col in zip(rows, cols):
        aabb = float(aabb_matrix[row, col])
        obb = float(obb_matrix[row, col])
        if aabb <= 0.0 and obb <= 0.0:
            continue
        gt_name = gt_names[row]
        pred_name = pred_names[col]
        used_gt.add(gt_name)
        used_pred.add(pred_name)
        matched_aabb.append(aabb)
        matched_obb.append(obb)
        matches.append(
            {
                "gt_name": gt_name,
                "pred_name": pred_name,
                "aabb_iou": aabb,
                "obb_iou": obb,
            }
        )

    denom = max(len(gt_names), len(pred_names), 1)
    return {
        "aabb_penalized": float(np.sum(matched_aabb) / denom),
        "obb_penalized": float(np.sum(matched_obb) / denom),
        "aabb_matched_mean": float(np.mean(matched_aabb)) if matched_aabb else 0.0,
        "obb_matched_mean": float(np.mean(matched_obb)) if matched_obb else 0.0,
        "matches": matches,
        "unmatched_gt": sorted(set(gt_names) - used_gt),
        "unmatched_pred": sorted(set(pred_names) - used_pred),
    }


def ioub_aligned(
    bbox_mod: Any,
    gt_payload: dict[str, Any],
    pred_payload: dict[str, Any],
    transform: dict[str, Any],
    *,
    ground_policy: str = "exclude",
) -> dict[str, Any]:
    gt_frames = gt_payload["objects_per_frame"]
    pred_frames = pred_payload["objects_per_frame"]
    target = min(len(gt_frames), len(pred_frames))
    gt_idx = _aligned_indices(len(gt_frames), target)
    pred_idx = _aligned_indices(len(pred_frames), target)
    gt_matrix = np.asarray(transform.get("gt_matrix", np.eye(4)), dtype=np.float64)
    pred_matrix = np.asarray(transform.get("pred_matrix", transform["matrix"]), dtype=np.float64)

    scene_aabb_frames: list[float] = []
    scene_obb_frames: list[float] = []
    obj_aabb_pen_frames: list[float] = []
    obj_obb_pen_frames: list[float] = []
    frame_details: list[dict[str, Any]] = []

    for gi, pi in zip(gt_idx, pred_idx):
        gt_map = _transformed_mesh_map(bbox_mod, gt_frames[gi], gt_matrix)
        pred_map = _transformed_mesh_map(bbox_mod, pred_frames[pi], pred_matrix)

        if ground_policy == "exclude":


            gt_map = _drop_ground_from_map(gt_map)
            pred_map = _drop_ground_from_map(pred_map)

        gt_scene_vertices = bbox_mod._stack_vertices(gt_map)
        pred_scene_vertices = bbox_mod._stack_vertices(pred_map)
        scene_aabb, scene_obb = _bbox_iou_for_meshes(bbox_mod, gt_scene_vertices, pred_scene_vertices)
        scene_aabb_frames.append(scene_aabb)
        scene_obb_frames.append(scene_obb)

        obj_match = _match_objects_by_iou(bbox_mod, gt_map, pred_map)
        obj_aabb_pen_frames.append(float(obj_match["aabb_penalized"]))
        obj_obb_pen_frames.append(float(obj_match["obb_penalized"]))

        frame_details.append(
            {
                "gt_frame_no": int(gt_payload["frame_indices"][gi]),
                "pred_frame_no": int(pred_payload["frame_indices"][pi]),
                "scene_aabb_iou": scene_aabb,
                "scene_obb_iou": scene_obb,
                "gt_object_count": len(gt_map),
                "pred_object_count": len(pred_map),
                "matched_object_count": len(obj_match["matches"]),
                "object_match_mode": "hungarian_aabb_iou",
                "ground_policy": ground_policy,
                "object_aabb_iou_penalized": obj_match["aabb_penalized"],
                "object_obb_iou_penalized": obj_match["obb_penalized"],
                "matched_object_mean_aabb": obj_match["aabb_matched_mean"],
                "matched_object_mean_obb": obj_match["obb_matched_mean"],
                "unmatched_gt": obj_match["unmatched_gt"],
                "unmatched_pred": obj_match["unmatched_pred"],
                "per_object_matched": obj_match["matches"],
            }
        )

    return {
        "scene_aabb_iou_frames": scene_aabb_frames,
        "scene_obb_iou_frames": scene_obb_frames,
        "object_aabb_iou_penalized_frames": obj_aabb_pen_frames,
        "object_obb_iou_penalized_frames": obj_obb_pen_frames,
        "scene_aabb_iou_mean": float(np.mean(scene_aabb_frames)) if scene_aabb_frames else 0.0,
        "scene_obb_iou_mean": float(np.mean(scene_obb_frames)) if scene_obb_frames else 0.0,
        "object_aabb_iou_penalized_mean": float(np.mean(obj_aabb_pen_frames)) if obj_aabb_pen_frames else 0.0,
        "object_obb_iou_penalized_mean": float(np.mean(obj_obb_pen_frames)) if obj_obb_pen_frames else 0.0,
        "frame_details": frame_details,
    }


def read_image_rgb(path: Path) -> np.ndarray:
    bgr = cv2.imread(str(path), cv2.IMREAD_COLOR)
    if bgr is None:
        raise ValueError(f"Unable to decode image: {path}")
    return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)


def _align_image_paths(gt_images: tuple[Path, ...], pred_images: tuple[Path, ...]) -> list[tuple[Path, Path]]:
    if not gt_images or not pred_images:
        return []
    target = min(len(gt_images), len(pred_images))
    gt_idx = _aligned_indices(len(gt_images), target)
    pred_idx = _aligned_indices(len(pred_images), target)
    return [(gt_images[g], pred_images[p]) for g, p in zip(gt_idx, pred_idx)]


def photometric_loss_image(gt_frame: np.ndarray, pred_frame: np.ndarray) -> float:
    if pred_frame.shape[:2] != gt_frame.shape[:2]:
        h, w = gt_frame.shape[:2]
        pred_frame = cv2.resize(pred_frame, (w, h), interpolation=cv2.INTER_AREA)
    gt = gt_frame[..., :3].astype(np.float32) / 255.0
    pred = pred_frame[..., :3].astype(np.float32) / 255.0
    return float(np.mean(np.square(gt - pred)))


def pl_images(gt_images: tuple[Path, ...], pred_images: tuple[Path, ...]) -> dict[str, Any]:
    pairs = _align_image_paths(gt_images, pred_images)
    if not pairs:
        raise FileNotFoundError("PL requires at least one GT image and one prediction image")
    losses = [photometric_loss_image(read_image_rgb(g), read_image_rgb(p)) for g, p in pairs]
    raw = float(np.mean(losses))
    return {
        "metric": "PhotometricLoss_SelectedImages",
        "pl_raw": raw,
        "score_100": float(lower_is_better_to_score(raw, bad_value=1.0)),
        "frame_count": len(pairs),
        "mode": "selected_images",
        "gt_frame_count": len(gt_images),
        "pred_frame_count": len(pred_images),
        "pairs": [{"gt": str(g), "pred": str(p)} for g, p in pairs],
        "frame_losses": losses,
        "direction": "lower_is_better",
    }


def _encode_image_features(
    images: list[Image.Image],
    model: Any,
    processor: Any,
    device: str,
    batch_size: int,
) -> Any:
    import torch

    feats: list[torch.Tensor] = []
    with torch.no_grad():
        for start in range(0, len(images), batch_size):
            chunk = images[start : start + batch_size]
            inputs = processor(images=chunk, return_tensors="pt")
            inputs = {k: v.to(device) for k, v in inputs.items()}
            image_features = model.get_image_features(**inputs)
            image_features = image_features / image_features.norm(dim=-1, keepdim=True)
            feats.append(image_features)
    return torch.cat(feats, dim=0)


def nclip_images(
    gt_images: tuple[Path, ...],
    pred_images: tuple[Path, ...],
    model: Any,
    processor: Any,
    device: str,
    batch_size: int,
) -> dict[str, Any]:
    import torch

    pairs = _align_image_paths(gt_images, pred_images)
    if not pairs:
        raise FileNotFoundError("N-CLIP requires at least one GT image and one prediction image")
    gt_pil = [Image.fromarray(read_image_rgb(g)) for g, _ in pairs]
    pred_pil = [Image.fromarray(read_image_rgb(p)) for _, p in pairs]
    gt_feat = _encode_image_features(gt_pil, model, processor, device, batch_size)
    pred_feat = _encode_image_features(pred_pil, model, processor, device, batch_size)
    sims = torch.nn.functional.cosine_similarity(pred_feat, gt_feat, dim=-1)
    sim_values = sims.detach().cpu().numpy().astype(float).tolist()
    nclip_values = [float(1.0 - x) for x in sim_values]
    raw = float(np.mean(nclip_values))
    return {
        "metric": "VIGA_N_CLIP_SelectedImages",
        "n_clip_raw": raw,
        "clip_similarity_mean": float(np.mean(sim_values)),
        "score_100": float(100.0 * max(0.0, min(1.0, 1.0 - raw))),
        "frame_count": len(pairs),
        "mode": "selected_images_image_image",
        "pairs": [{"gt": str(g), "pred": str(p)} for g, p in pairs],
        "frame_clip_similarity": sim_values,
        "frame_n_clip": nclip_values,
        "formula": "mean_i(1 - CLIPSim(pred_image_i, gt_image_i))",
        "direction": "lower_is_better",
    }


def _missing_visual_metric(
    name: str,
    gt_images: tuple[Path, ...],
    pred_images: tuple[Path, ...],
    *,
    reason: str = "missing selected images",
) -> dict[str, Any]:
    return {
        "metric": name,
        "skipped": True,
        "reason": reason,
        "gt_frame_count": len(gt_images),
        "pred_frame_count": len(pred_images),
        "score_100": 0.0,
    }


def main() -> None:
    args = parse_args()

    project_root = _project_root()
    data_root = _resolve_data_root(project_root, args.data_root)
    out_json = Path(args.out_json).resolve()
    out_json.parent.mkdir(parents=True, exist_ok=True)
    alignment_dir = Path(args.alignment_dir).resolve() if args.alignment_dir else out_json.parent / "alignments"
    alignment_dir.mkdir(parents=True, exist_ok=True)
    scene_meta_dir = Path(args.scene_meta_dir).resolve() if args.scene_meta_dir else out_json.parent / "scene_meta"
    if args.scene_meta_dir and not scene_meta_dir.is_absolute():
        scene_meta_dir = (project_root / scene_meta_dir).resolve()

    gt_key = args.gt_key
    models = [x.strip() for x in args.models.split(",") if x.strip()]
    if not models:
        raise ValueError("models list is empty")

    all_assets = {
        k: load_assets(
            data_root,
            k,
            args.sample_id,
            image_glob=args.image_glob,
            scene_filename=args.scene_filename,
        )
        for k in [gt_key] + models
    }
    if args.auto_scene_meta and args.alignment == "depth_camera":
        all_assets = {
            k: ensure_scene_meta(
                v,
                project_root=project_root,
                blender_bin=args.blender_bin,
                scene_meta_dir=scene_meta_dir,
            )
            for k, v in all_assets.items()
        }

    bbox_mod = import_bbox_helpers(project_root)
    extract_script = project_root / "scripts" / "extract_blend_meshes.py"
    payload_cache: dict[str, dict[str, Any]] = {}

    gt_payload = _load_payload(
        all_assets[gt_key].scene,
        blender_bin=args.blender_bin,
        extract_script=extract_script,
        frame_mode=args.geometry_frame_mode,
        payload_cache=payload_cache,
    )

    ious: dict[str, Any] = {}
    alignments: dict[str, Any] = {}
    for key in models:
        pred_payload = _load_payload(
            all_assets[key].scene,
            blender_bin=args.blender_bin,
            extract_script=extract_script,
            frame_mode=args.geometry_frame_mode,
            payload_cache=payload_cache,
        )
        transform = build_alignment_transform(
            gt_payload,
            pred_payload,
            gt_depth=all_assets[gt_key].depth,
            pred_depth=all_assets[key].depth,
            gt_camera=all_assets[gt_key].camera,
            pred_camera=all_assets[key].camera,
            mode=args.alignment,
            bbox_mod=bbox_mod,
            camera_convention=args.camera_convention,
            camera_rotation_only=args.camera_rotation_only,
            ground_policy=args.ground_policy,
        )
        align_path = alignment_dir / args.sample_id / key / "alignment_transform.json"
        align_path.parent.mkdir(parents=True, exist_ok=True)
        transform_with_paths = {
            **transform,
            "gt_scene": str(all_assets[gt_key].scene),
            "pred_scene": str(all_assets[key].scene),
        }
        align_path.write_text(json.dumps(transform_with_paths, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
        alignments[key] = {**transform_with_paths, "path": str(align_path)}
        ious[key] = ioub_aligned(
            bbox_mod,
            gt_payload,
            pred_payload,
            transform,
            ground_policy=args.ground_policy,
        )

    pl_nclip: dict[str, Any] = {}
    if args.skip_selected_image_metrics:
        device = "skipped"
        for key in models:
            gt_images = all_assets[gt_key].images
            pred_images = all_assets[key].images
            pl_nclip[key] = {
                "media_type": "selected_images",
                "gt_images": [str(x) for x in gt_images],
                "pred_images": [str(x) for x in pred_images],
                "pl": _missing_visual_metric(
                    "PhotometricLoss_SelectedImages",
                    gt_images,
                    pred_images,
                    reason="disabled by --skip_selected_image_metrics",
                ),
                "n_clip": _missing_visual_metric(
                    "VIGA_N_CLIP_SelectedImages",
                    gt_images,
                    pred_images,
                    reason="disabled by --skip_selected_image_metrics",
                ),
            }
    else:
        import torch
        from transformers import CLIPModel, CLIPProcessor

        clip_model = CLIPModel.from_pretrained(args.clip_model_path, local_files_only=True)
        clip_processor = CLIPProcessor.from_pretrained(args.clip_model_path, local_files_only=True)
        device = "cuda" if torch.cuda.is_available() else "cpu"
        clip_model = clip_model.to(device)
        clip_model.eval()

        for key in models:
            gt_images = all_assets[gt_key].images
            pred_images = all_assets[key].images
            if not gt_images or not pred_images:
                if not args.allow_missing_images:
                    raise FileNotFoundError(
                        f"Missing selected images for model={key}: "
                        f"gt_count={len(gt_images)} pred_count={len(pred_images)}"
                    )
                pl = _missing_visual_metric("PhotometricLoss_SelectedImages", gt_images, pred_images)
                n_clip = _missing_visual_metric("VIGA_N_CLIP_SelectedImages", gt_images, pred_images)
            else:
                pl = pl_images(gt_images, pred_images)
                n_clip = nclip_images(
                    gt_images,
                    pred_images,
                    clip_model,
                    clip_processor,
                    device,
                    args.clip_batch_size,
                )
            pl_nclip[key] = {
                "media_type": "selected_images",
                "gt_images": [str(x) for x in gt_images],
                "pred_images": [str(x) for x in pred_images],
                "pl": pl,
                "n_clip": n_clip,
            }

    summary = []
    for key in models:
        summary.append(
            {
                "model": key,
                "scene_aabb_iou_mean": ious[key]["scene_aabb_iou_mean"],
                "scene_obb_iou_mean": ious[key]["scene_obb_iou_mean"],
                "object_aabb_iou_penalized_mean": ious[key]["object_aabb_iou_penalized_mean"],
                "object_obb_iou_penalized_mean": ious[key]["object_obb_iou_penalized_mean"],
                "pl_score_100": pl_nclip[key]["pl"]["score_100"],
                "n_clip_score_100": pl_nclip[key]["n_clip"]["score_100"],
                "pl_raw": pl_nclip[key]["pl"].get("pl_raw"),
                "n_clip_raw": pl_nclip[key]["n_clip"].get("n_clip_raw"),
                "alignment_mode": alignments[key]["mode"],
                "alignment_scale": alignments[key]["scale"],
            }
        )

    output = {
        "sample_id": args.sample_id,
        "paths": {
            k: {
                "base": str(v.base),
                "scene": str(v.scene),
                "images": [str(x) for x in v.images],
                "text": str(v.text) if v.text else None,
                "depth": str(v.depth) if v.depth else None,
                "camera": str(v.camera) if v.camera else None,
                "generated_meta": str(v.generated_meta) if v.generated_meta else None,
            }
            for k, v in all_assets.items()
        },
        "runtime": {
            "blender_bin": args.blender_bin,
            "clip_model_path": args.clip_model_path,
            "clip_device": device,
        },
        "rules": {
            "asset_loader": "auto-detect scene.blend/scene.glb/scene.gltf and selected images",
            "auto_scene_meta": bool(args.auto_scene_meta),
            "scene_meta_dir": str(scene_meta_dir),
            "iou_b_frames": args.geometry_frame_mode,
            "alignment": args.alignment,
            "ground_policy": args.ground_policy,
            "alignment_transform": "saved per model before IoU under alignment_dir",
            "iou_b_object_matching": "Hungarian matching on object AABB IoU; penalty denominator=max(gt_count,pred_count)",
            "selected_image_metrics_skipped": bool(args.skip_selected_image_metrics),
            "pl_definition": "MSE on user-selected image frames only",
            "n_clip_definition": "VIGA-style mean(1 - CLIPSim(pred_selected_image, gt_selected_image))",
        },
        "alignments": alignments,
        "iou_b": ious,
        "pl_nclip": pl_nclip,
        "summary": summary,
        "rankings": {
            "scene_aabb_desc": sorted(summary, key=lambda x: x["scene_aabb_iou_mean"], reverse=True),
            "scene_obb_desc": sorted(summary, key=lambda x: x["scene_obb_iou_mean"], reverse=True),
            "object_aabb_pen_desc": sorted(summary, key=lambda x: x["object_aabb_iou_penalized_mean"], reverse=True),
            "object_obb_pen_desc": sorted(summary, key=lambda x: x["object_obb_iou_penalized_mean"], reverse=True),
            "pl_score_desc": sorted(summary, key=lambda x: x["pl_score_100"], reverse=True),
            "nclip_score_desc": sorted(summary, key=lambda x: x["n_clip_score_100"], reverse=True),
        },
    }

    out_json.write_text(json.dumps(output, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    print(json.dumps(output, indent=2, ensure_ascii=False))
    print(f"SAVED {out_json}")


if __name__ == "__main__":
    main()