| from __future__ import annotations |
|
|
| import importlib.util |
| import json |
| import sys |
| import tempfile |
| import unittest |
| from pathlib import Path |
| from types import SimpleNamespace |
|
|
| import numpy as np |
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[1] |
| def _load_script_module(): |
| script_path = PROJECT_ROOT / "scripts" / "run_big_eval.py" |
| spec = importlib.util.spec_from_file_location("run_big_eval", script_path) |
| if spec is None or spec.loader is None: |
| raise RuntimeError("Unable to load run_big_eval module") |
| mod = importlib.util.module_from_spec(spec) |
| sys.modules[spec.name] = mod |
| spec.loader.exec_module(mod) |
| return mod |
|
|
|
|
| def _mesh(vertices): |
| return SimpleNamespace(vertices=np.asarray(vertices, dtype=np.float64), faces=np.zeros((0, 3), dtype=np.int64)) |
|
|
|
|
| def _box(lo, hi): |
| x0, y0, z0 = lo |
| x1, y1, z1 = hi |
| return np.array( |
| [ |
| [x0, y0, z0], |
| [x1, y0, z0], |
| [x0, y1, z0], |
| [x1, y1, z0], |
| [x0, y0, z1], |
| [x1, y0, z1], |
| [x0, y1, z1], |
| [x1, y1, z1], |
| ], |
| dtype=np.float64, |
| ) |
|
|
|
|
| class FakeBBoxMod: |
| @staticmethod |
| def _to_mesh_map(raw): |
| return raw |
|
|
| @staticmethod |
| def _stack_vertices(mesh_map): |
| if not mesh_map: |
| return np.zeros((0, 3), dtype=np.float64) |
| return np.concatenate([m.vertices for m in mesh_map.values()], axis=0) |
|
|
| @staticmethod |
| def _aabb_from_vertices(vertices): |
| if vertices.size == 0: |
| return None |
| return SimpleNamespace( |
| min_bound=np.min(vertices, axis=0), |
| max_bound=np.max(vertices, axis=0), |
| volume=float(np.prod(np.max(vertices, axis=0) - np.min(vertices, axis=0))), |
| ) |
|
|
| @staticmethod |
| def _aabb_iou(a, b): |
| 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 = float(np.prod(inter_ext)) |
| union = a.volume + b.volume - inter |
| return inter / union if union > 0.0 else 1.0 |
|
|
| @staticmethod |
| def _obb_from_vertices(vertices): |
| return FakeBBoxMod._aabb_from_vertices(vertices) |
|
|
| @staticmethod |
| def _obb_iou(a, b): |
| return FakeBBoxMod._aabb_iou(a, b) |
|
|
|
|
| class TestBigEvalHelpers(unittest.TestCase): |
| def test_asset_loader_prefers_scene_glb_when_no_blend(self) -> None: |
| mod = _load_script_module() |
|
|
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| sample = root / "sam3d" / "s1" |
| frames = sample / "selected_frames" |
| frames.mkdir(parents=True) |
| (sample / "scene.glb").write_bytes(b"glb") |
| (sample / "description.txt").write_text("scene", encoding="utf-8") |
| (frames / "000.png").write_bytes(b"png") |
|
|
| assets = mod.load_assets( |
| root, |
| "sam3d", |
| "s1", |
| image_glob="selected_frames/*,scene.png", |
| scene_filename=None, |
| ) |
|
|
| self.assertEqual(assets.scene, (sample / "scene.glb").resolve()) |
| self.assertEqual(assets.images, ((frames / "000.png").resolve(),)) |
| self.assertEqual(assets.text, (sample / "description.txt").resolve()) |
|
|
| def test_bbox_alignment_maps_pred_center_to_gt_center(self) -> None: |
| mod = _load_script_module() |
| gt_payload = { |
| "objects_per_frame": [{"gt": _mesh(_box([0, 0, 0], [2, 2, 2]))}], |
| } |
| pred_payload = { |
| "objects_per_frame": [{"pred": _mesh(_box([10, 0, 0], [11, 1, 1]))}], |
| } |
|
|
| transform = mod.build_alignment_transform( |
| gt_payload, |
| pred_payload, |
| gt_depth=None, |
| pred_depth=None, |
| mode="bbox", |
| bbox_mod=FakeBBoxMod, |
| ) |
| matrix = np.asarray(transform["matrix"], dtype=np.float64) |
| pred_center = np.array([[10.5, 0.5, 0.5]], dtype=np.float64) |
| mapped = mod._transform_vertices(pred_center, matrix)[0] |
|
|
| np.testing.assert_allclose(mapped, np.array([1.0, 1.0, 1.0]), atol=1e-7) |
| self.assertAlmostEqual(transform["scale"], 2.0, places=7) |
|
|
| def test_object_bbox_alignment_anchors_best_object_not_scene(self) -> None: |
| mod = _load_script_module() |
| gt_payload = { |
| "objects_per_frame": [ |
| { |
| "armchair": _mesh(_box([0, 0, 0], [2, 2, 2])), |
| "far_object": _mesh(_box([20, 0, 0], [21, 1, 1])), |
| } |
| ], |
| } |
| pred_payload = { |
| "objects_per_frame": [{"object_1_armchair": _mesh(_box([10, 0, 0], [11, 1, 1]))}], |
| } |
|
|
| transform = mod.build_alignment_transform( |
| gt_payload, |
| pred_payload, |
| gt_depth=None, |
| pred_depth=None, |
| mode="object_bbox", |
| bbox_mod=FakeBBoxMod, |
| ) |
| matrix = np.asarray(transform["matrix"], dtype=np.float64) |
| pred_center = np.array([[10.5, 0.5, 0.5]], dtype=np.float64) |
| mapped = mod._transform_vertices(pred_center, matrix)[0] |
|
|
| np.testing.assert_allclose(mapped, np.array([1.0, 1.0, 1.0]), atol=1e-7) |
| self.assertAlmostEqual(transform["scale"], 2.0, places=7) |
| self.assertEqual(transform["scale_source"], "best_object_bbox_diag") |
| self.assertEqual(transform["alignment_anchor"]["gt_name"], "armchair") |
| self.assertEqual(transform["alignment_anchor"]["pred_name"], "object_1_armchair") |
|
|
| def test_object_matching_uses_iou_not_name(self) -> None: |
| mod = _load_script_module() |
| gt_map = {"chair": _mesh(_box([0, 0, 0], [1, 1, 1]))} |
| pred_map = {"object_0007": _mesh(_box([0, 0, 0], [1, 1, 1]))} |
|
|
| result = mod._match_objects_by_iou(FakeBBoxMod, gt_map, pred_map) |
|
|
| self.assertAlmostEqual(result["aabb_penalized"], 1.0, places=7) |
| self.assertEqual(result["matches"][0]["gt_name"], "chair") |
| self.assertEqual(result["matches"][0]["pred_name"], "object_0007") |
|
|
| def test_depth_camera_alignment_canonicalizes_first_frame_rotation_and_scale(self) -> None: |
| mod = _load_script_module() |
|
|
|
|
|
|
| theta = np.pi / 2.0 |
| rz = np.array( |
| [ |
| [np.cos(theta), -np.sin(theta), 0.0], |
| [np.sin(theta), np.cos(theta), 0.0], |
| [0.0, 0.0, 1.0], |
| ], |
| dtype=np.float64, |
| ) |
| gt_w2c = np.eye(4, dtype=np.float64) |
| gt_w2c[:3, :3] = rz |
| pred_w2c = np.eye(4, dtype=np.float64) |
|
|
| gt_canonical = _box([1, 0, 0], [3, 1, 1]) |
| gt_world = gt_canonical @ rz |
| pred_world = gt_canonical * 0.5 |
|
|
| gt_payload = { |
| "frame_indices": [0], |
| "objects_per_frame": [{"gt": _mesh(gt_world)}], |
| } |
| pred_payload = { |
| "frame_indices": [0], |
| "objects_per_frame": [{"pred": _mesh(pred_world)}], |
| } |
|
|
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| gt_depth = root / "gt_depth.npy" |
| pred_depth = root / "pred_depth.npy" |
| gt_camera = root / "gt_camera.json" |
| pred_camera = root / "pred_camera.json" |
| np.save(gt_depth, np.full((4, 4), 2.0, dtype=np.float32)) |
| np.save(pred_depth, np.full((4, 4), 1.0, dtype=np.float32)) |
| gt_camera.write_text(json.dumps({"world_to_camera": gt_w2c.tolist()}), encoding="utf-8") |
| pred_camera.write_text(json.dumps({"world_to_camera": pred_w2c.tolist()}), encoding="utf-8") |
|
|
| transform = mod.build_alignment_transform( |
| gt_payload, |
| pred_payload, |
| gt_depth=gt_depth, |
| pred_depth=pred_depth, |
| gt_camera=gt_camera, |
| pred_camera=pred_camera, |
| mode="depth_camera", |
| bbox_mod=FakeBBoxMod, |
| ) |
|
|
| result = mod.ioub_aligned(FakeBBoxMod, gt_payload, pred_payload, transform) |
|
|
| self.assertEqual(transform["scale_source"], "depth_median_ratio") |
| self.assertAlmostEqual(transform["scale"], 2.0, places=7) |
| self.assertAlmostEqual(result["scene_aabb_iou_mean"], 1.0, places=7) |
| self.assertAlmostEqual(result["object_aabb_iou_penalized_mean"], 1.0, places=7) |
|
|
| def test_scene_meta_cache_populates_missing_camera_and_depth(self) -> None: |
| mod = _load_script_module() |
|
|
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| base = root / "gt" / "s1" |
| base.mkdir(parents=True) |
| scene = base / "scene.glb" |
| scene.write_bytes(b"glb") |
|
|
| meta_root = root / "meta" |
| asset = mod.AssetBundle( |
| key="gt", |
| base=base, |
| scene=scene, |
| images=(), |
| text=None, |
| depth=None, |
| camera=None, |
| generated_meta=None, |
| ) |
| out_dir = mod._scene_meta_cache_dir(meta_root, asset) |
| out_dir.mkdir(parents=True) |
| (out_dir / "camera.json").write_text( |
| json.dumps({"world_to_camera": np.eye(4).tolist()}), |
| encoding="utf-8", |
| ) |
| np.save(out_dir / "depth.npy", np.ones((4, 4), dtype=np.float32)) |
|
|
| populated = mod.ensure_scene_meta( |
| asset, |
| project_root=PROJECT_ROOT, |
| blender_bin="unused", |
| scene_meta_dir=meta_root, |
| ) |
|
|
| self.assertEqual(populated.camera, out_dir / "camera.json") |
| self.assertEqual(populated.depth, out_dir / "depth.npy") |
| self.assertEqual(populated.generated_meta, out_dir) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
