gather gt from full dataset (part 3)

README.md

@@ -15,16 +15,27 @@ tags:
 20 indoor scenes rendered from [3D-FRONT](https://tianchi.aliyun.com/specials/promotion/alibaba-3d-scene-dataset).
 Each scene is one RGB view with metric depth, an empty-room depth map, ground-truth object
 meshes, and per-object 3D boxes — for single-image 3D scene reconstruction and evaluation.
-~305 MiB.
+19 of the 20 scenes additionally ship a **full-resolution instance mask** and **complete
+per-object / whole-scene meshes** recovered from the source 3D-FRONT room (see
+[Instance-level GT](#instance-level-gt-from-3d-front)). ~305 MiB.
 
 ```
-<index>/                        # e.g. 3025, index06 = 003025
-├── rgb_<index06>.jpeg          # 1296x968 RGB
-├── depth_<index06>.npy         # (968, 1296) float64, metric z-depth
-├── bgdepth_<index06>.npy       # (484, 648)  float64, depth of the empty room (half res)
-├── annotation_<index06>.json   # intrinsics, extrinsics, per-object boxes + labels
-└── sceneobjgt_<index06>.ply    # GT object meshes, OpenCV camera frame
-lift_3d_pcd.py                  # reference loader: depth -> point cloud, + viewer
+<index>/                            # e.g. 3025, index06 = 003025
+├── rgb_<index06>.jpeg              # 1296x968 RGB
+├── depth_<index06>.npy             # (968, 1296) float64, metric z-depth
+├── bgdepth_<index06>.npy           # (484, 648)  float64, depth of the empty room (half res)
+├── annotation_<index06>.json       # intrinsics, extrinsics, per-object boxes + labels
+├── sceneobjgt_<index06>.ply        # partial GT object meshes (as shipped), OpenCV camera frame
+│
+│   # instance-level GT aligned from 3D-FRONT (19/20 scenes; absent for 3966):
+├── instance_<index06>.png          # (968, 1296) uint16 instance-id mask (0 = background)
+├── instance_<index06>.json         # id -> {label, obj_id, model_uuid, n_pixels, ...} + match/similarity
+├── instance_overlay_<index06>.png  # RGB with the coloured mask blended in, for eyeballing
+├── sceneobjfull_<index06>.ply      # all objects merged, OpenCV camera frame
+└── objects_<index06>/              # per-object meshes: <instid:03d>_<label>.ply
+lift_3d_pcd.py                      # reference loader: depth -> point cloud, + viewer
+build_gt_from_3dfront.py            # regenerates the instance-level GT from 3D-FRONT
+gt_3dfront_summary.json             # per-scene match report (room, depth-agreement stats)
 ```
 
 Scenes: `3025 3084 3126 3200 3266 3277 3376 3392 3401 3431 3454 3477 3844 3847 3966 4033 4087 4091 4124 4135`
@@ -62,6 +73,38 @@ Each `obj_dict` entry has `label` / `cls_id`, `obj_id` / `model_file_name`,
 `obj_tran` / `obj_rot` (local→world) / `obj_scale`, `bbox3d_world` (3, 8) corners,
 `bbox3d_world_center` + `half_length`, `bbox3d_camera`, the 2D boxes, and `occ_iou`.
 
+## Instance-level GT (from 3D-FRONT)
+
+Because `single_image` is a subset of 3D-FRONT, each view is re-aligned to its source
+3D-FRONT room to recover a **complete** instance mask and object meshes (the shipped
+`sceneobjgt_*.ply` is only a partial merge). `build_gt_from_3dfront.py` does this:
+
+1. index each furniture model UUID → the 3D-FRONT rooms containing it (from the
+   `*_full.glb` scene graphs);
+2. shortlist rooms whose models cover the annotation and RANSAC-fit the glb→world
+   similarity transform from object-centroid correspondences;
+3. disambiguate the room by ray-casting the placed objects through the annotation
+   intrinsics and comparing the rendered z-depth against the metric `depth`;
+4. write the outputs above into the scene folder.
+
+Objects only — walls / floor / ceiling are excluded. The meshes are in the **OpenCV**
+camera frame (same as `sceneobjgt_*` / the lifted cloud), so `sceneobjfull_*.ply` overlays
+`depth` directly. `instance_*.png` is full resolution and aligned to `rgb_*`; ids `1..N`
+index the `objects_<index06>/` meshes and the `instances` list in `instance_*.json`.
+
+Coverage: **19/20 scenes** align to < 1.5 mm median depth error (> 87 % of object pixels
+within 5 mm; see `gt_3dfront_summary.json`). **3966 is intentionally omitted** — its
+objects are near-coplanar (six identical chairs) so the room could not be recovered
+reliably; it keeps only the originally shipped files.
+
+Regenerate (needs `pip install trimesh embreex pillow`; uses a model-UUID index built from
+the local 3D-FRONT copy):
+
+```bash
+python build_gt_from_3dfront.py                 # all scenes
+python build_gt_from_3dfront.py --scenes 3025   # one scene
+```
+
 ## Point clouds and visualization
 
 `lift_3d_pcd.py` sits in the dataset root and finds the scenes next to itself, so it runs

build_gt_from_3dfront.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python
+"""Build per-view GT (instance mask + object meshes) for the Fire3D single_image
+scenes by aligning the source 3D-FRONT room to each annotation and ray-casting it
+into the annotation camera.
+
+Pipeline per scene (see the discussion in the task):
+  1. shortlist candidate 3D-FRONT rooms whose furniture-model UUID set covers the
+     annotation's objects (index built from the ``*_full.glb`` scene graphs);
+  2. estimate the glb->annotation-world similarity transform with a RANSAC over
+     per-model candidate matches (robust to duplicate models / extra room objects);
+  3. for the top-K candidates, ray-cast the placed room objects through the
+     annotation intrinsics and keep the room whose rendered depth best agrees with
+     the dataset metric depth;
+  4. write outputs: uint16 instance mask (full-res, aligned to rgb), id->object
+     json, per-object meshes (PLY, OpenCV camera frame = the sceneobjgt frame),
+     merged scene-objects mesh, and an rgb overlay for eyeballing the match.
+
+Objects only: walls / floor / ceiling are intentionally skipped.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import re
+import warnings
+from itertools import combinations, product
+from typing import Any
+
+import numpy as np
+import trimesh
+from PIL import Image
+
+warnings.filterwarnings("ignore")
+
+UUID_RE = re.compile(r"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})")
+SCENE_ROOT = "/mnt/task_runtime/3d-front/3D-FRONT-SCENE"
+SI_ROOT = "/mnt/task_runtime/data/single_image"
+CV2GL = np.diag([1.0, -1.0, -1.0])                       # OpenCV cam <-> OpenGL cam
+CANONICAL_R = np.array([[1.0, 0, 0], [0, 0, -1.0], [0, 1.0, 0]])  # glb y-up -> world z-up
+PALETTE = np.array([
+    [230, 25, 75], [60, 180, 75], [255, 225, 25], [0, 130, 200], [245, 130, 48],
+    [145, 30, 180], [70, 240, 240], [240, 50, 230], [210, 245, 60], [250, 190, 212],
+    [0, 128, 128], [220, 190, 255], [170, 110, 40], [255, 250, 200], [128, 0, 0],
+    [170, 255, 195], [128, 128, 0], [255, 215, 180], [0, 0, 128], [128, 128, 128],
+], dtype=np.uint8)
+
+
+def umeyama(src: np.ndarray, dst: np.ndarray, fixed_r: np.ndarray | None = None
+            ) -> tuple[float, np.ndarray, np.ndarray]:
+    """Fit a similarity transform ``dst ~= s * R @ src + t`` (Umeyama, 1991).
+
+    If ``fixed_r`` is given the rotation is held fixed and only scale/translation
+    are estimated (used when only two correspondences are available).
+    """
+    mu_s, mu_d = src.mean(0), dst.mean(0)
+    s_c, d_c = src - mu_s, dst - mu_d
+    if fixed_r is None:
+        cov = d_c.T @ s_c / len(src)
+        u, d, vt = np.linalg.svd(cov)
+        rot = u @ vt
+        if np.linalg.det(rot) < 0:
+            u[:, -1] *= -1
+            rot = u @ vt
+        scale = float(np.trace(np.diag(d)) / ((s_c ** 2).sum() / len(src)))
+    else:
+        rot = fixed_r
+        scale = float((d_c * (s_c @ rot.T)).sum() / (s_c ** 2).sum())
+    trans = mu_d - scale * rot @ mu_s
+    return scale, rot, trans
+
+
+def load_room_objects(scene_uuid: str, room: str) -> dict[str, tuple[trimesh.Trimesh, str]]:
+    """Load furniture nodes of ``<room>_full.glb`` as ``node_name -> (mesh, model_uuid)``.
+
+    Architecture / unnamed geometry (walls, floor, ceiling) carry no model UUID in
+    the node name and are skipped, so only objects are returned.
+    """
+    full = os.path.join(SCENE_ROOT, scene_uuid, f"{room}_full.glb")
+    if not os.path.exists(full):
+        return {}
+    scene = trimesh.load(full)
+    nodes: dict[str, tuple[trimesh.Trimesh, str]] = {}
+    for name in scene.graph.nodes_geometry:
+        m = UUID_RE.search(name)
+        if not m:
+            continue
+        transform, geom_name = scene.graph[name]
+        geom = scene.geometry[geom_name].copy()
+        geom.apply_transform(transform)
+        nodes[name] = (geom, m.group(1))
+    return nodes
+
+
+def fit_similarity(ann: dict[str, Any],
+                   nodes: dict[str, tuple[trimesh.Trimesh, str]],
+                   thresh: float = 0.15) -> dict[str, Any] | None:
+    """RANSAC estimate of the glb->annotation-world similarity transform.
+
+    Each annotation object may match several same-model room nodes; we sample
+    triples of (object, candidate-node) hypotheses, fit a similarity, and score it
+    by the number of annotation objects whose nearest same-model node lands within
+    ``thresh`` metres. Returns the transform plus the inlier node->object assignment.
+    """
+    ann_obj = [(o["model_file_name"][0], np.array(o["bbox3d_world_center"], float), oid)
+               for oid, o in enumerate(ann["obj_dict"].values())]
+    node_by_uuid: dict[str, list[tuple[str, np.ndarray]]] = {}
+    for name, (geom, mid) in nodes.items():
+        node_by_uuid.setdefault(mid, []).append((name, geom.bounds.mean(0)))
+    cand = [[(nm, c) for nm, c in node_by_uuid.get(mid, [])] for mid, _, _ in ann_obj]
+    have = [i for i, c in enumerate(cand) if c]
+    if len(have) < 2:
+        return None
+
+    def score(scale: float, rot: np.ndarray, trans: np.ndarray
+              ) -> tuple[list[float], dict[str, int]]:
+        res: list[float] = []
+        assign: dict[str, int] = {}
+        for i in have:
+            dst = ann_obj[i][1]
+            nm, c = min(cand[i], key=lambda nc: np.linalg.norm(scale * (rot @ nc[1]) + trans - dst))
+            d = float(np.linalg.norm(scale * (rot @ c) + trans - dst))
+            if d < thresh:
+                res.append(d)
+                assign[nm] = ann_obj[i][2]
+        return res, assign
+
+    best: tuple[tuple[int, float], float, np.ndarray, np.ndarray, list[float], dict[str, int]] | None = None
+    if len(have) >= 3:
+        trip = sorted(have, key=lambda i: len(cand[i]))[:min(len(have), 6)]
+        for combo in combinations(trip, 3):
+            for picks in product(*[cand[i] for i in combo]):
+                src = np.array([p[1] for p in picks])
+                dst = np.array([ann_obj[i][1] for i in combo])
+                if not (np.isfinite(src).all() and np.isfinite(dst).all()):
+                    continue
+                try:
+                    scale, rot, trans = umeyama(src, dst)
+                except np.linalg.LinAlgError:
+                    continue
+                res, assign = score(scale, rot, trans)
+                key = (len(res), -float(np.sum(res)) if res else 0.0)
+                if best is None or key > best[0]:
+                    best = (key, scale, rot, trans, res, assign)
+    if best is None:  # two-object scene: fix the canonical rotation
+        src = np.array([cand[i][0][1] for i in have])
+        dst = np.array([ann_obj[i][1] for i in have])
+        gm = np.isfinite(src).all(1) & np.isfinite(dst).all(1)
+        if gm.sum() < 2:
+            return None
+        try:
+            scale, rot, trans = umeyama(src[gm], dst[gm], CANONICAL_R)
+        except np.linalg.LinAlgError:
+            return None
+        res, assign = score(scale, rot, trans)
+        best = ((len(res), 0.0), scale, rot, trans, res, assign)
+    _, scale, rot, trans, res, assign = best
+    if not res:
+        return None
+    return dict(scale=scale, rot=rot, trans=trans, n_inliers=len(res),
+                max_res=float(np.max(res)), med_res=float(np.median(res)), assign=assign)
+
+
+def camera_from_annotation(ann: dict[str, Any]) -> tuple[np.ndarray, np.ndarray]:
+    """Return ``(K, T_cv_from_world)``: intrinsics and world->OpenCV-camera 4x4."""
+    k = np.asarray(ann["camera_intrinsics"], float)
+    w2c = np.eye(4)
+    w2c[:3] = np.asarray(ann["camera_extrinsics"], float)          # world -> OpenGL cam
+    rot, trans = w2c[:3, :3], w2c[:3, 3]
+    t_world_from_cv = np.eye(4)
+    t_world_from_cv[:3, :3] = rot.T @ CV2GL
+    t_world_from_cv[:3, 3] = -rot.T @ trans
+    return k, np.linalg.inv(t_world_from_cv)
+
+
+def place_objects(nodes: dict[str, tuple[trimesh.Trimesh, str]], fit: dict[str, Any],
+                  t_cv_from_world: np.ndarray
+                  ) -> list[tuple[str, str, trimesh.Trimesh]]:
+    """Transform each room object node glb->world (similarity)->OpenCV camera frame.
+
+    Returns a deterministic list of ``(node_name, model_uuid, mesh_in_camera_frame)``.
+    """
+    scale, rot, trans = fit["scale"], fit["rot"], fit["trans"]
+    placed: list[tuple[str, str, trimesh.Trimesh]] = []
+    for name in sorted(nodes):
+        geom, mid = nodes[name]
+        mesh = geom.copy()
+        mesh.vertices = scale * (rot @ mesh.vertices.T).T + trans     # -> world
+        mesh.apply_transform(t_cv_from_world)                          # -> camera (cv)
+        placed.append((name, mid, mesh))
+    return placed
+
+
+def raycast_instance_mask(placed: list[tuple[str, str, trimesh.Trimesh]],
+                          k: np.ndarray, hw: tuple[int, int], stride: int = 1
+                          ) -> tuple[np.ndarray, np.ndarray]:
+    """Ray-cast placed objects through ``K``; return ``(instance_id_map, z_depth)``.
+
+    Instance ids are ``1..len(placed)`` (0 = background); the nearest surface wins
+    per pixel. ``z_depth`` is the camera-frame z of the hit (inf where no hit).
+    """
+    height, width = hw
+    faces_obj = np.concatenate([np.full(len(m.faces), i + 1, np.int32)
+                                for i, (_, _, m) in enumerate(placed)])
+    combined = trimesh.util.concatenate([m for _, _, m in placed])
+    fx, fy, cx, cy = k[0, 0], k[1, 1], k[0, 2], k[1, 2]
+    us, vs = np.meshgrid(np.arange(0, width, stride), np.arange(0, height, stride))
+    flat_u, flat_v = us.ravel(), vs.ravel()
+    dirs = np.stack([(flat_u - cx) / fx, (flat_v - cy) / fy, np.ones_like(flat_u, float)], -1)
+    dirs /= np.linalg.norm(dirs, axis=1, keepdims=True)
+    origins = np.zeros_like(dirs)
+    loc, ray_idx, tri_idx = combined.ray.intersects_location(origins, dirs, multiple_hits=False)
+    id_flat = np.zeros(flat_u.shape, np.int32)
+    z_flat = np.full(flat_u.shape, np.inf)
+    for r, tri, xyz in zip(ray_idx, tri_idx, loc):
+        if xyz[2] < z_flat[r]:
+            z_flat[r] = xyz[2]
+            id_flat[r] = faces_obj[tri]
+    out_h, out_w = us.shape
+    return id_flat.reshape(out_h, out_w), z_flat.reshape(out_h, out_w)
+
+
+def depth_agreement(z_render: np.ndarray, depth: np.ndarray) -> dict[str, float]:
+    """Agreement between rendered object z and dataset metric depth on covered pixels."""
+    valid = np.isfinite(z_render) & np.isfinite(depth) & (depth > 0) & (depth < 100)
+    if valid.sum() == 0:
+        return dict(coverage=0.0, med_mm=float("inf"), within5mm=0.0, n=0)
+    err = np.abs(z_render[valid] - depth[valid])
+    return dict(coverage=float(np.isfinite(z_render).mean()),
+                med_mm=float(np.median(err) * 1000), within5mm=float((err < 0.005).mean()),
+                n=int(valid.sum()))
+
+
+def shortlist_rooms(ann: dict[str, Any], u2rooms: dict[str, set[str]]) -> list[str]:
+    """Rooms whose model set covers all annotation models (else the best-covering ones)."""
+    uuids = set(o["model_file_name"][0] for o in ann["obj_dict"].values())
+    sets = [u2rooms.get(u, set()) for u in uuids]
+    if sets and all(sets):
+        common = set.intersection(*sets)
+        if common:
+            return sorted(common)
+    from collections import Counter
+    counter: Counter[str] = Counter()
+    for s in sets:
+        counter.update(s)
+    if not counter:
+        return []
+    top = max(counter.values())
+    return sorted(r for r, n in counter.items() if n == top)
+
+
+def process_scene(scene_id: str, u2rooms: dict[str, set[str]], out_root: str,
+                  top_k: int, sel_stride: int, min_conf: float = 0.5) -> dict[str, Any]:
+    """Match one scene to its 3D-FRONT room and, if confident, write GT into the
+    scene folder next to the original files, using the ``_<index06>`` naming.
+
+    Low-confidence matches (rendered depth disagrees with the metric depth) are
+    not written; the scene is reported as ``low-confidence`` instead.
+    """
+    scene_dir = os.path.join(out_root, scene_id)
+    idx6 = f"{int(scene_id):06d}"
+    ann = json.load(open(glob.glob(f"{scene_dir}/annotation_*.json")[0]))
+    k, t_cv_from_world = camera_from_annotation(ann)
+    depth = np.load(glob.glob(f"{scene_dir}/depth_*.npy")[0]).astype(np.float64)
+    height, width = depth.shape
+
+    candidates = shortlist_rooms(ann, u2rooms)
+    scored: list[tuple[tuple[int, float], str, str, dict[str, Any]]] = []
+    for room_key in candidates:
+        scene_uuid, room = room_key.split("|")
+        nodes = load_room_objects(scene_uuid, room)
+        if not nodes:
+            continue
+        fit = fit_similarity(ann, nodes)
+        if fit is None:
+            continue
+        scored.append(((-fit["n_inliers"], fit["max_res"]), scene_uuid, room, fit))
+    if not scored:
+        return dict(scene=scene_id, status="no-match", n_candidates=len(candidates))
+    scored.sort(key=lambda x: x[0])
+
+    # verify the top-K by rendered-depth agreement (decisive for ambiguous scenes)
+    best = None
+    for _, scene_uuid, room, fit in scored[:top_k]:
+        nodes = load_room_objects(scene_uuid, room)
+        placed = place_objects(nodes, fit, t_cv_from_world)
+        _, z_low = raycast_instance_mask(placed, k, (height, width), stride=sel_stride)
+        agree = depth_agreement(z_low, depth[::sel_stride, ::sel_stride])
+        key = (agree["within5mm"], -agree["med_mm"])
+        if best is None or key > best[0]:
+            best = (key, scene_uuid, room, fit, agree)
+    _, scene_uuid, room, fit, _ = best
+
+    # full-res render for the winner
+    nodes = load_room_objects(scene_uuid, room)
+    placed = place_objects(nodes, fit, t_cv_from_world)
+    id_map, z_render = raycast_instance_mask(placed, k, (height, width), stride=1)
+    agree = depth_agreement(z_render, depth)
+
+    # id -> object metadata (computed before writing so we can gate on confidence)
+    ann_by_oid = list(ann["obj_dict"].values())
+    id_records: list[dict[str, Any]] = []
+    for i, (name, mid, _) in enumerate(placed):
+        inst = i + 1
+        category = UUID_RE.split(name)[0].strip("_")
+        oid = fit["assign"].get(name)
+        label = ann_by_oid[oid]["label"][0] if oid is not None else category
+        n_pix = int((id_map == inst).sum())
+        id_records.append(dict(instance_id=inst, node_name=name, model_uuid=mid,
+                               category=category, label=label, annotated=oid is not None,
+                               obj_id=int(ann_by_oid[oid]["obj_id"][0]) if oid is not None else None,
+                               n_pixels=n_pix, visible=n_pix > 0))
+
+    confident = agree["within5mm"] >= min_conf
+    result = dict(scene=scene_id, status="ok" if confident else "low-confidence",
+                  scene_uuid=scene_uuid, room=room, confident=confident,
+                  n_candidates=len(candidates), n_objects=len(placed),
+                  n_annotated=sum(r["annotated"] for r in id_records),
+                  fit=dict(scale=fit["scale"], n_inliers=fit["n_inliers"],
+                           max_res=fit["max_res"], med_res=fit["med_res"]),
+                  depth=agree, instances=id_records)
+    if not confident:
+        return result  # do not write GT for an unreliable match
+
+    # write GT into the scene folder, matching the dataset's _<index06> convention
+    obj_dir = os.path.join(scene_dir, f"objects_{idx6}")
+    os.makedirs(obj_dir, exist_ok=True)
+    Image.fromarray(id_map.astype(np.uint16)).save(os.path.join(scene_dir, f"instance_{idx6}.png"))
+    merged: list[trimesh.Trimesh] = []
+    for (name, _, mesh), rec in zip(placed, id_records):
+        safe = re.sub(r"[^0-9a-zA-Z]+", "_", rec["label"]).strip("_")[:32]
+        mesh.export(os.path.join(obj_dir, f"{rec['instance_id']:03d}_{safe}.ply"))
+        merged.append(mesh)
+    trimesh.util.concatenate(merged).export(os.path.join(scene_dir, f"sceneobjfull_{idx6}.ply"))
+    save_overlay(scene_dir, id_map, os.path.join(scene_dir, f"instance_overlay_{idx6}.png"))
+    json.dump({k2: v for k2, v in result.items() if k2 != "instances"} | {
+        "similarity": dict(scale=fit["scale"], rot=fit["rot"].tolist(), trans=fit["trans"].tolist()),
+        "instances": id_records}, open(os.path.join(scene_dir, f"instance_{idx6}.json"), "w"), indent=2)
+    return result
+
+
+def save_overlay(scene_dir: str, id_map: np.ndarray, path: str) -> None:
+    """Blend the coloured instance mask over the rgb image for visual inspection."""
+    rgb_path = (glob.glob(f"{scene_dir}/rgb_*.jpeg") + glob.glob(f"{scene_dir}/rgb_*.png"))[0]
+    rgb = np.asarray(Image.open(rgb_path).convert("RGB"))
+    if rgb.shape[:2] != id_map.shape:
+        rgb = np.asarray(Image.fromarray(rgb).resize((id_map.shape[1], id_map.shape[0])))
+    color = np.zeros_like(rgb)
+    for inst in np.unique(id_map):
+        if inst == 0:
+            continue
+        color[id_map == inst] = PALETTE[(inst - 1) % len(PALETTE)]
+    fg = id_map > 0
+    out = rgb.copy()
+    out[fg] = (0.5 * rgb[fg] + 0.5 * color[fg]).astype(np.uint8)
+    Image.fromarray(out).save(path)
+
+
+def main() -> None:
+    """CLI entry point: match and export GT for one or all single_image scenes."""
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--scenes", nargs="*", default=None, help="scene ids (default: all)")
+    ap.add_argument("--index", default="/tmp/uuid_index.json",
+                    help="model-uuid -> [[scene,room],...] index json")
+    ap.add_argument("--out", default=SI_ROOT,
+                    help="dataset root; GT is written into each <out>/<scene>/ folder")
+    ap.add_argument("--top-k", type=int, default=8, help="candidates to depth-verify")
+    ap.add_argument("--sel-stride", type=int, default=4, help="pixel stride for verification")
+    args = ap.parse_args()
+
+    idx = json.load(open(args.index))
+    u2rooms = {u: set(f"{a}|{b}" for a, b in v) for u, v in idx.items()}
+    scenes = args.scenes or [os.path.basename(p) for p in sorted(glob.glob(f"{args.out}/[0-9]*"))]
+
+    summary = []
+    for sid in scenes:
+        try:
+            res = process_scene(sid, u2rooms, args.out, args.top_k, args.sel_stride)
+        except Exception as exc:  # noqa: BLE001 - keep the batch going
+            res = dict(scene=sid, status=f"error:{type(exc).__name__}:{exc}")
+        summary.append(res)
+        if res["status"] in ("ok", "low-confidence"):
+            d = res["depth"]
+            flag = "" if res["confident"] else "  <-- LOW CONFIDENCE (skipped, likely wrong room)"
+            print(f"{sid}: {res['scene_uuid'][:8]}/{res['room']:26} "
+                  f"obj={res['n_objects']:2d} ann={res['n_annotated']} "
+                  f"cover={d['coverage']*100:4.1f}% med={d['med_mm']:5.1f}mm "
+                  f"<5mm={d['within5mm']*100:4.1f}%{flag}")
+        else:
+            print(f"{sid}: {res['status']}")
+    json.dump(summary, open(os.path.join(args.out, "gt_3dfront_summary.json"), "w"), indent=2)
+
+
+if __name__ == "__main__":
+    main()