| from __future__ import annotations |
|
|
| import argparse |
| import itertools |
| import json |
| import pickle |
| import subprocess |
| import tempfile |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from scipy.spatial import ConvexHull |
|
|
|
|
| EPS = 1e-9 |
|
|
|
|
| @dataclass |
| class AABB: |
| min_bound: np.ndarray |
| max_bound: np.ndarray |
|
|
| @property |
| def extents(self) -> np.ndarray: |
| return np.maximum(self.max_bound - self.min_bound, 0.0) |
|
|
| @property |
| def volume(self) -> float: |
| return float(np.prod(self.extents)) |
|
|
|
|
| @dataclass |
| class OBB: |
| center: np.ndarray |
| axes: np.ndarray |
| half_lengths: np.ndarray |
|
|
| @property |
| def extents(self) -> np.ndarray: |
| return 2.0 * self.half_lengths |
|
|
| @property |
| def volume(self) -> float: |
| return float(np.prod(np.maximum(self.extents, 0.0))) |
|
|
|
|
| @dataclass |
| class MeshData: |
| vertices: np.ndarray |
| faces: np.ndarray |
|
|
|
|
| def _extractor_script_path() -> Path: |
| return Path(__file__).resolve().parent / "extract_blend_meshes.py" |
|
|
|
|
| def _run_extract( |
| blend_path: Path, |
| out_path: Path, |
| *, |
| blender_bin: str, |
| frame_mode: str, |
| ) -> None: |
| cmd = [ |
| blender_bin, |
| "--factory-startup", |
| "--background", |
| str(blend_path), |
| "--python", |
| str(_extractor_script_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( |
| "Blend mesh extraction failed\n" |
| f"command: {' '.join(cmd)}\n" |
| f"stdout:\n{proc.stdout}\n" |
| f"stderr:\n{proc.stderr}\n" |
| ) |
|
|
|
|
| def _load_payload(path: Path) -> dict[str, Any]: |
| with path.open("rb") as f: |
| return pickle.load(f) |
|
|
|
|
| def _to_mesh_map(raw: dict[str, dict[str, np.ndarray]]) -> dict[str, MeshData]: |
| out: dict[str, MeshData] = {} |
| for name, item in raw.items(): |
| out[name] = MeshData( |
| vertices=np.asarray(item["vertices"], dtype=np.float64), |
| faces=np.asarray(item["faces"], dtype=np.int64), |
| ) |
| return out |
|
|
|
|
| def _stack_vertices(mesh_map: dict[str, MeshData]) -> np.ndarray: |
| chunks: list[np.ndarray] = [] |
| for mesh in mesh_map.values(): |
| if mesh.vertices.size == 0: |
| continue |
| chunks.append(mesh.vertices) |
| if not chunks: |
| return np.zeros((0, 3), dtype=np.float64) |
| return np.concatenate(chunks, axis=0) |
|
|
|
|
| def _aabb_from_vertices(vertices: np.ndarray) -> AABB | None: |
| if vertices.size == 0: |
| return None |
| return AABB( |
| min_bound=np.min(vertices, axis=0), |
| max_bound=np.max(vertices, axis=0), |
| ) |
|
|
|
|
| def _aabb_iou(a: AABB | None, b: AABB | None) -> float: |
| if a is None and b is None: |
| return 1.0 |
| if a is None or b is None: |
| return 0.0 |
|
|
| inter_min = np.maximum(a.min_bound, b.min_bound) |
| inter_max = np.minimum(a.max_bound, b.max_bound) |
| inter_ext = np.maximum(inter_max - inter_min, 0.0) |
| inter_vol = float(np.prod(inter_ext)) |
| union_vol = a.volume + b.volume - inter_vol |
| if union_vol <= EPS: |
| return 1.0 |
| return float(np.clip(inter_vol / union_vol, 0.0, 1.0)) |
|
|
|
|
| def _safe_rotation(matrix: np.ndarray) -> np.ndarray: |
| u, _, vt = np.linalg.svd(matrix) |
| rot = u @ vt |
| if np.linalg.det(rot) < 0: |
| u[:, -1] *= -1.0 |
| rot = u @ vt |
| return rot |
|
|
|
|
| def _pca_obb_from_vertices(vertices: np.ndarray) -> OBB | None: |
| pts = vertices |
| if pts.shape[0] > 2000: |
| try: |
| pts = vertices[ConvexHull(vertices).vertices] |
| except Exception: |
| pts = vertices |
| mean = pts.mean(axis=0) |
| centered = pts - mean |
|
|
| _, _, vt = np.linalg.svd(centered, full_matrices=False) |
| rot = _safe_rotation(vt.T) |
|
|
| proj = (vertices - mean) @ rot |
| lo = proj.min(axis=0) |
| hi = proj.max(axis=0) |
| center = mean + rot @ (0.5 * (lo + hi)) |
| half_lengths = np.maximum(0.5 * (hi - lo), 0.0) |
| axes = np.column_stack( |
| [rot[:, i] / max(np.linalg.norm(rot[:, i]), EPS) for i in range(3)] |
| ) |
| return OBB(center=center, axes=axes, half_lengths=half_lengths) |
|
|
|
|
| def _obb_from_vertices(vertices: np.ndarray) -> OBB | None: |
| if vertices.size == 0: |
| return None |
|
|
| try: |
| return _pca_obb_from_vertices(vertices) |
| except Exception: |
| aabb = _aabb_from_vertices(vertices) |
| if aabb is None: |
| return None |
| center = 0.5 * (aabb.min_bound + aabb.max_bound) |
| half_lengths = 0.5 * np.maximum(aabb.max_bound - aabb.min_bound, 0.0) |
| return OBB(center=center, axes=np.eye(3, dtype=np.float64), half_lengths=half_lengths) |
|
|
|
|
| def _obb_halfspaces(obb: OBB) -> list[tuple[np.ndarray, float]]: |
| planes: list[tuple[np.ndarray, float]] = [] |
| c = obb.center |
| for i in range(3): |
| axis = obb.axes[:, i] |
| axis = axis / max(np.linalg.norm(axis), EPS) |
| half = float(max(obb.half_lengths[i], 0.0)) |
| planes.append((axis, half + float(np.dot(axis, c)))) |
| planes.append((-axis, half - float(np.dot(axis, c)))) |
| return planes |
|
|
|
|
| def _intersection_volume_halfspaces( |
| planes: list[tuple[np.ndarray, float]], |
| *, |
| plane_tol: float = 1e-8, |
| dedup_tol: float = 1e-7, |
| ) -> float: |
| points: list[np.ndarray] = [] |
|
|
| for combo in itertools.combinations(range(len(planes)), 3): |
| normals = np.stack([planes[i][0] for i in combo], axis=0) |
| det = float(np.linalg.det(normals)) |
| if abs(det) < plane_tol: |
| continue |
| rhs = np.array([planes[i][1] for i in combo], dtype=np.float64) |
| x = np.linalg.solve(normals, rhs) |
|
|
| ok = True |
| for n, d in planes: |
| if float(np.dot(n, x)) - d > plane_tol: |
| ok = False |
| break |
| if ok: |
| points.append(x) |
|
|
| if len(points) < 4: |
| return 0.0 |
|
|
| arr = np.asarray(points, dtype=np.float64) |
| quant = np.round(arr / dedup_tol).astype(np.int64) |
| _, unique_idx = np.unique(quant, axis=0, return_index=True) |
| arr = arr[np.sort(unique_idx)] |
| if arr.shape[0] < 4: |
| return 0.0 |
|
|
| try: |
| hull = ConvexHull(arr) |
| return float(max(hull.volume, 0.0)) |
| except Exception: |
| return 0.0 |
|
|
|
|
| def _obb_iou(a: OBB | None, b: OBB | None) -> float: |
| if a is None and b is None: |
| return 1.0 |
| if a is None or b is None: |
| return 0.0 |
|
|
| vol_a = a.volume |
| vol_b = b.volume |
| if vol_a <= EPS and vol_b <= EPS: |
| return 1.0 |
| if vol_a <= EPS or vol_b <= EPS: |
| return 0.0 |
|
|
| planes = _obb_halfspaces(a) + _obb_halfspaces(b) |
| inter_vol = _intersection_volume_halfspaces(planes) |
| union_vol = vol_a + vol_b - inter_vol |
| if union_vol <= EPS: |
| return 0.0 |
| return float(np.clip(inter_vol / union_vol, 0.0, 1.0)) |
|
|
|
|
| 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 _evaluate( |
| gt_payload: dict[str, Any], |
| pred_payload: dict[str, Any], |
| ) -> dict[str, Any]: |
| gt_frames_raw = gt_payload["objects_per_frame"] |
| pred_frames_raw = pred_payload["objects_per_frame"] |
|
|
| target = min(len(gt_frames_raw), len(pred_frames_raw)) |
| gt_idx = _aligned_indices(len(gt_frames_raw), target) |
| pred_idx = _aligned_indices(len(pred_frames_raw), target) |
|
|
| scene_aabb_ious: list[float] = [] |
| scene_obb_ious: list[float] = [] |
| object_aabb_ious: list[float] = [] |
| object_obb_ious: list[float] = [] |
| frame_details: list[dict[str, Any]] = [] |
|
|
| for gi, pi in zip(gt_idx, pred_idx): |
| gt_map = _to_mesh_map(gt_frames_raw[gi]) |
| pred_map = _to_mesh_map(pred_frames_raw[pi]) |
|
|
| gt_scene_vertices = _stack_vertices(gt_map) |
| pred_scene_vertices = _stack_vertices(pred_map) |
|
|
| scene_aabb = _aabb_iou( |
| _aabb_from_vertices(gt_scene_vertices), |
| _aabb_from_vertices(pred_scene_vertices), |
| ) |
| scene_obb = _obb_iou( |
| _obb_from_vertices(gt_scene_vertices), |
| _obb_from_vertices(pred_scene_vertices), |
| ) |
| scene_aabb_ious.append(scene_aabb) |
| scene_obb_ious.append(scene_obb) |
|
|
| matched = sorted(set(gt_map.keys()) & set(pred_map.keys())) |
| per_object: list[dict[str, Any]] = [] |
| cur_obj_aabb: list[float] = [] |
| cur_obj_obb: list[float] = [] |
|
|
| for name in matched: |
| gt_vertices = gt_map[name].vertices |
| pred_vertices = pred_map[name].vertices |
| aabb_iou = _aabb_iou(_aabb_from_vertices(gt_vertices), _aabb_from_vertices(pred_vertices)) |
| obb_iou = _obb_iou(_obb_from_vertices(gt_vertices), _obb_from_vertices(pred_vertices)) |
| cur_obj_aabb.append(aabb_iou) |
| cur_obj_obb.append(obb_iou) |
| per_object.append( |
| { |
| "name": name, |
| "aabb_iou": aabb_iou, |
| "obb_iou": obb_iou, |
| } |
| ) |
|
|
| frame_object_aabb = float(np.mean(cur_obj_aabb)) if cur_obj_aabb else 0.0 |
| frame_object_obb = float(np.mean(cur_obj_obb)) if cur_obj_obb else 0.0 |
| object_aabb_ious.append(frame_object_aabb) |
| object_obb_ious.append(frame_object_obb) |
|
|
| frame_details.append( |
| { |
| "gt_frame_idx": int(gi), |
| "pred_frame_idx": int(pi), |
| "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, |
| "matched_object_count": len(matched), |
| "object_aabb_iou_mean": frame_object_aabb, |
| "object_obb_iou_mean": frame_object_obb, |
| "per_object": per_object, |
| } |
| ) |
|
|
| return { |
| "metric": "BBoxIoU_AABB_OBB", |
| "direction": "higher_is_better", |
| "scene_aabb_iou_frames": scene_aabb_ious, |
| "scene_aabb_iou_mean": float(np.mean(scene_aabb_ious)) if scene_aabb_ious else 0.0, |
| "scene_obb_iou_frames": scene_obb_ious, |
| "scene_obb_iou_mean": float(np.mean(scene_obb_ious)) if scene_obb_ious else 0.0, |
| "object_aabb_iou_frames": object_aabb_ious, |
| "object_aabb_iou_mean": float(np.mean(object_aabb_ious)) if object_aabb_ious else 0.0, |
| "object_obb_iou_frames": object_obb_ious, |
| "object_obb_iou_mean": float(np.mean(object_obb_ious)) if object_obb_ious else 0.0, |
| "frame_details": frame_details, |
| } |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| p = argparse.ArgumentParser(description="Evaluate AABB/OBB IoU between two blend files") |
| p.add_argument("--gt_blend", required=True) |
| p.add_argument("--pred_blend", required=True) |
| p.add_argument("--blender_bin", default="blender") |
| p.add_argument( |
| "--frame_mode", |
| default="first_mid_last", |
| help="Frame sampling mode: first_only, first_mid_last, last_only, or exact:<frame>", |
| ) |
| p.add_argument("--save_json", default=None) |
| return p |
|
|
|
|
| def main() -> None: |
| args = build_parser().parse_args() |
|
|
| gt_blend = Path(args.gt_blend).resolve() |
| pred_blend = Path(args.pred_blend).resolve() |
| if not gt_blend.exists(): |
| raise FileNotFoundError(f"Missing gt blend: {gt_blend}") |
| if not pred_blend.exists(): |
| raise FileNotFoundError(f"Missing pred blend: {pred_blend}") |
|
|
| with tempfile.TemporaryDirectory(prefix="bbox_iou_blend_") as td: |
| tmp = Path(td) |
| gt_pkl = tmp / "gt_meshes.pkl" |
| pred_pkl = tmp / "pred_meshes.pkl" |
| _run_extract(gt_blend, gt_pkl, blender_bin=args.blender_bin, frame_mode=args.frame_mode) |
| _run_extract(pred_blend, pred_pkl, blender_bin=args.blender_bin, frame_mode=args.frame_mode) |
|
|
| gt_payload = _load_payload(gt_pkl) |
| pred_payload = _load_payload(pred_pkl) |
| result = _evaluate(gt_payload, pred_payload) |
|
|
| output = { |
| "gt_blend": str(gt_blend), |
| "pred_blend": str(pred_blend), |
| "config": { |
| "blender_bin": args.blender_bin, |
| "frame_mode": args.frame_mode, |
| }, |
| "result": result, |
| } |
|
|
| payload = json.dumps(output, indent=2, ensure_ascii=False) |
| print(payload) |
|
|
| if args.save_json: |
| out_path = Path(args.save_json).resolve() |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| out_path.write_text(payload + "\n", encoding="utf-8") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
