Remove old encoder before replacement

encoder/.ipynb_checkpoints/geometric-checkpoint.py

@@ -1,2333 +0,0 @@
-"""Geometric assembler (runs in the pipeline venv). Imported by encoder/render.py.
-
-Pure math/assembly -- builds the per-instance spatial code (object positions/sizes, pairwise
-distances, closeness ranks, room outline, camera trajectory, appearance order) FROM
-already-computed depth/pose/masks. Does NOT run DA3 or SAM3, and does not call cache_or_load()
--- that's run.py's job entirely (the only file that calls the actual model-inference functions).
-Callers may provide raw depth/intr/c2w/conf/ftimes/per inputs or canonical world-space
-geometry; both feed build_compact_spatial_code() (see its own docstring for how it handles
-that duality). The explicit schema is no longer built independently: it is a strict derivation
-of the compact schema (build_explicit_spatial_code() calls build_compact_spatial_code() first,
-then reads every explicit value directly off compact's own oriented boxes and floor polygons --
-positions/dimensions/counts/appearance-order are direct subsets, and the distance table is
-computed purely from compact's 3D oriented boxes). This guarantees the two schemas can never
-silently disagree about the same scene's geometry.
-
-Formerly this file called into perceptual.py (as a dynamically-loaded `pl` module) for its own
-geometry helpers -- build_instances, room_gravity, answer_closest_distance, and everything else
-in this file below _room_outline(). Those functions are now merged in directly, verbatim, since
-they were never DA3/SAM3 calls -- they're geometric computations over already-extracted
-depth/masks, which is exactly this file's job. perceptual.py's OTHER half (the actual
-model-calling functions) moved to run.py instead; perceptual.py itself no longer exists.
-
-The spatial code is the sole spatial representation the downstream VLM sees; no answer engine
-is computed here (the harness runs the model).
-"""
-
-from __future__ import annotations
-
-import os
-import json
-import numpy as np
-import cv2
-
-# ==========================================================================================
-# CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
-# affect only the math below (build_instances/backproject_frame/etc.), never model inference.
-# ==========================================================================================
-
-SCHEMA = [
-    "x",
-    "y",
-    "z",
-    "e1",
-    "e2",
-    "e3",
-    "px",
-    "pz",
-    "size_median",
-    "size_IQR",
-    "time",
-    "n",
-]  # legacy row schema, see to_labeled()
-KD_WORKERS = max(1, int(os.environ.get("VSI_KD_WORKERS", "4")))
-# Batch workers set VSI_KD_WORKERS from their per-process CPU budget. Keeping a
-# bounded default avoids pathological all-core thread spawning for small queries.
-MIN_INSTANCE_PTS = (
-    1  # bare geometry floor only: need >=1 valid depth pixel to place a 3D point.
-)
-# NO quality filtering / dedup -- count = exactly SAM3's tracked masklets (honest)
-FLOOR_BAND = (
-    0.15  # m above the floor to count as floor-level (LEGACY -- currently unreferenced;
-)
-# compute_floor_area now uses the RANSAC gravity plane directly instead)
-# ---- geometry-cleanup levers (improve abs_distance etc.; env-tunable) ----
-# DEPTH_COHERENCE (Tukey-fence bleed removal): SAFE + helpful everywhere -> default ON.
-#   ablation: ARKit abs_distance 0.757->0.729 (no harm), ScanNet++ d755 0.443->0.486 (helps).
-# CONF_PCT (per-frame confidence percentile): noisy-dataset ONLY -> default OFF.
-#   helps ScanNet++ distance more (~0.56) but DESTROYS clean ARKit (0.757->0.429). Opt in via VSI_CONF_PCT=55.
-CONF_PCT = float(os.environ.get("VSI_CONF_PCT", "0"))
-DEPTH_COHERENCE = os.environ.get("VSI_DEPTH_COHERENCE", "1") == "1"
-# cut mask-bleed at per-frame depth edges. Default OFF: it's a NO-OP on the dominant failure (same-depth bleed
-# -- adjacent objects at similar range have no depth edge), and only helps depth-SEPARATED bleed. Enable per-need.
-DEPTH_EDGE_REFINE = os.environ.get("VSI_DEPTH_EDGE_REFINE", "0") == "1"
-# MASK_REFINE (appearance-guided boundary snap): uses the RGB color edge to clip same-depth mask bleed that
-#   depth can't see. Principled + cheap (CPU, no model). Default OFF until validated; enable via VSI_MASK_REFINE=1.
-MASK_REFINE = os.environ.get("VSI_MASK_REFINE", "0") == "1"
-
-
-# ==========================================================================================
-# ROOM/OBJECT GEOMETRY -- gravity, floor basis, per-instance spatial-code records. Merged in
-# from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def to_labeled(objects, floor_area):
-    """LEGACY per-class summary (kept for --format array-compat). Superseded by to_spatial_code."""
-    out = {"objects": {}}
-    for cls, row in objects.items():
-        d = dict(zip(SCHEMA, row))
-        out["objects"][cls] = {
-            "count": int(d["n"]),
-            "centroid_meters": {"x": d["x"], "y": d["y"], "z": d["z"]},
-            "longest_dimension_meters": {
-                "median": d["size_median"],
-                "iqr": d["size_IQR"],
-            },
-            "centroid_spread": {
-                "eigenvalues": [d["e1"], d["e2"], d["e3"]],
-                "principal_axis_xz": [d["px"], d["pz"]],
-            },
-            "first_seen_seconds": d["time"],
-        }
-    out["room"] = {"floor_area_square_meters": floor_area}
-    return out
-
-
-def room_up_axis(instances, c2w):
-    """up axis = smallest-extent axis of all object points; sign from gravity (floor->camera).
-    Floor = densest horizontal slab; cameras are always above it, which fixes the sign.
-    Returns (axis_index, signed_unit_vector)."""
-    points = np.concatenate([i["pts"] for v in instances.values() for i in v], 0)
-    ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-    up = int(np.argmin(ext))
-    h, edges = np.histogram(points[:, up], bins=80)
-    floor = 0.5 * (edges[h.argmax()] + edges[h.argmax() + 1])  # densest slab = floor
-    cam_up = c2w[:, :3, 3][:, up].mean()
-    e = np.zeros(3, np.float32)
-    e[up] = 1.0 if cam_up > floor else -1.0
-    return up, e
-
-
-def room_gravity(
-    depth, intr, c2w, conf, conf_pct=40, stride=12, fstride=15, iters=300, thr=0.05
-):
-    """Robust UP vector = normal of the RANSAC floor plane (a real physical plane), oriented toward
-    the cameras. Works when the reconstruction is tilted/drifted (ScanNet++) where argmin-extent fails.
-    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
-    """
-    points = []
-    for f in range(0, len(depth), fstride):
-        height, width = depth[f].shape
-        ys, xs = np.mgrid[0:height:stride, 0:width:stride]
-        ys = ys.ravel()
-        xs = xs.ravel()
-        z = depth[f][ys, xs]
-        ok = (z > 0) & np.isfinite(z)
-        if conf is not None and conf_pct > 0:
-            ok &= conf[f][ys, xs] >= np.percentile(conf[f], conf_pct)
-        ys, xs, z = ys[ok], xs[ok], z[ok]
-        if not len(z):
-            continue
-        intrinsics = intr[f]
-        camera_points = np.stack(
-            [
-                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
-                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
-                z,
-            ],
-            1,
-        )
-        points.append((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3])
-    points = np.concatenate(points).astype(np.float64) if points else np.zeros((0, 3))
-    cam = c2w[:, :3, 3].mean(0)
-    if len(points) < 100:  # fallback to axis-extent
-        ext = (
-            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-            if len(points)
-            else np.ones(3)
-        )
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return g, ax
-    rng = np.random.RandomState(0)
-    best = None
-    best_score = -1
-    for _ in range(iters):
-        a, b, c = points[rng.choice(len(points), 3, False)]
-        nrm = np.cross(b - a, c - a)
-        ln = np.linalg.norm(nrm)
-        if ln < 1e-6:
-            continue
-        nrm /= ln
-        d = -nrm @ a
-        side = points @ nrm + d
-        ninl = int((np.abs(side) < thr).sum())
-        if ninl < 50:
-            continue
-        score = ninl * max(
-            np.mean(side > thr), np.mean(side < -thr)
-        )  # big + one-sided = floor
-        if score > best_score:
-            best_score = score
-            best = (nrm, d)
-    if best is None:
-        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return g, ax
-    nrm, d = best
-    if (cam @ nrm + d) < 0:
-        nrm = -nrm  # orient toward cameras (up)
-    return nrm.astype(np.float32), int(np.argmax(np.abs(nrm)))
-
-
-def pos3(rec):
-    """Read either legacy numeric or current unit-string position formatting."""
-    p = rec.get("position") or {}
-
-    def meters(current, legacy):
-        value = p.get(current, p.get(legacy, 0.0))
-        if isinstance(value, str):
-            if value.endswith(" meters"):
-                value = value[: -len(" meters")]
-            value = value.strip()
-        return float(value)
-
-    return [
-        meters("x coordinate", "floor_x_meters"),
-        meters("y coordinate", "floor_y_meters"),
-        meters("height above floor", "height_above_floor_meters"),
-    ]
-
-
-def _floor_basis(up_vec):
-    """Orthonormal floor basis (u, v horizontal; g = up) from the gravity vector. u is the OLD
-    floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
-    differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
-    rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
-    """
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-    up_ax = int(np.argmax(np.abs(g)))
-    floor_axes = [
-        a for a in range(3) if a != up_ax
-    ]  # the two world axes the old frame used
-    e0 = np.zeros(3)
-    e0[floor_axes[0]] = 1.0  # old floor_x world axis
-    u = e0 - (e0 @ g) * g
-    u = u / (np.linalg.norm(u) + 1e-12)  # project it into the gravity plane
-    v = np.cross(g, u)
-    if v[floor_axes[1]] < 0:
-        v = -v  # keep floor_y sign aligned with the old axis
-    return u, v, g
-
-
-def _floor_level(points, gravity, v2=None):
-    """Reference floor estimator shared by every model representation.
-
-    The supplied geometry uses the densest gravity-height slab for its reproducible v1
-    behavior and the robust second percentile for v2.  Keep that switch here, after model
-    adapters have produced world points, so it cannot become model-specific.
-    """
-    heights = np.asarray(points, np.float64) @ np.asarray(gravity, np.float64)
-    heights = heights[np.isfinite(heights)]
-    if not len(heights):
-        return 0.0
-    if v2 is None:
-        v2 = os.environ.get("VSI_CODE_V2") == "1"
-    if v2:
-        return float(np.percentile(heights, 2))
-    counts, edges = np.histogram(heights, bins=80)
-    index = int(counts.argmax())
-    return float(0.5 * (edges[index] + edges[index + 1]))
-
-
-# ==========================================================================================
-# DETERMINISTIC ANSWER LAYER (parameter-free; validated on VSI GT). Reads the in-memory
-# instances (pos for direction/route, point clouds for distance). Merged in from
-# perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def _find_cls(name, classes):
-    """Mirrors symbolic/solver.py's _find_class exactly (see its docstring): word-TOKEN
-    subset, not raw character substring -- "washer" must not match "dishwasher" just
-    because the characters appear inside it (2026-07-26 fix, found via the citation-
-    fidelity audit)."""
-    name = name.strip().lower()
-    for c in classes:
-        if c == name or c.replace(" ", "") == name.replace(" ", ""):
-            return c
-    name_tokens = set(name.split())
-    for c in classes:
-        class_tokens = set(c.split())
-        if (
-            name_tokens
-            and class_tokens
-            and (name_tokens <= class_tokens or class_tokens <= name_tokens)
-        ):
-            return c
-    return None
-
-
-def _rep(insts):
-    """representative instance = most observed points (best-segmented, validated 8/8 on direction)."""
-    return max(insts, key=lambda i: i["n"])
-
-
-def answer_rel_direction(point_a, point_b, point_c, up_vec, up_ax, mode="hard"):
-    """Standing at A facing B, where is C? front/back=dot(C-A,fwd); left/right=dot(C-A, up x fwd).
-    Right-handed world (OpenCV cam frame + det+1 c2w) makes up x fwd = left a fixed identity.
-    Projection uses the gravity VECTOR (v-(v.g)g), so a tilted floor (ScanNet++) is handled; for an
-    axis-aligned up this reduces to zeroing that axis (ARKit unchanged)."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-
-    def fl(v):
-        w = v.astype(np.float64)
-        return w - (w @ g) * g
-
-    fwd = fl(point_b - point_a)
-    n = np.linalg.norm(fwd)
-    if n < 1e-6:
-        return None
-    fwd /= n
-    left = np.cross(g, fwd)
-    left /= np.linalg.norm(left) + 1e-9
-    d = fl(point_c - point_a)
-    f = float(d @ fwd)
-    lateral = float(d @ left)
-    if mode == "medium":
-        if abs(np.degrees(np.arctan2(lateral, f))) >= 135:
-            return "back"
-        return "left" if lateral > 0 else "right"
-    return f"{'front' if f > 0 else 'back'}-{'left' if lateral > 0 else 'right'}"
-
-
-def _classify_turn(h_in, h_out, up_vec, up_ax):
-    """rotation h_in->h_out in floor plane -> turn left/right/back (135deg = VSI's own 'back' cutoff)."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-
-    def fl(v):
-        w = v.astype(np.float64)
-        return w - (w @ g) * g
-
-    a, b = fl(h_in), fl(h_out)
-    na, nb = np.linalg.norm(a), np.linalg.norm(b)
-    if na < 1e-6 or nb < 1e-6:
-        return None
-    a /= na
-    b /= nb
-    ang = np.degrees(np.arctan2(float(up_vec @ np.cross(a, b)), float(a @ b)))
-    if abs(ang) >= 135:
-        return "turn back"
-    return "turn left" if ang > 0 else "turn right"
-
-
-def answer_route(ql, cents, up_vec, up_ax):
-    """Chain the turn primitive over the waypoint sequence -> ordered ['turn left/right/back', ...]."""
-    import re as _re
-
-    m = _re.search(r"beginning at the (.+?) (?:and )?facing the (.+?)\.", ql)
-    if not m:
-        return None
-
-    def position(name):
-        class_name = _find_cls(name, cents)
-        return cents[class_name] if class_name else None
-
-    steps_txt = ql.split(":", 1)[1] if ":" in ql else ql
-    steps = _re.findall(
-        r"\d+\.\s*(\[please fill in\]|Go forward until the [^0-9\[]+?)(?=\s*\d+\.|$)",
-        steps_txt,
-    )
-    cur_pos = position(m.group(1).strip())
-    if cur_pos is None:
-        return None
-    fac = position(m.group(2).strip())
-    cur_head = (fac - cur_pos) if fac is not None else None
-    turns = []
-    i = 0
-    while i < len(steps):
-        s = steps[i].strip()
-        if s.startswith("Go forward"):
-            tp = position(_re.sub(r"^Go forward until the ", "", s).strip().rstrip("."))
-            if tp is not None:
-                cur_head = tp - cur_pos
-                cur_pos = tp
-        else:
-            nxt = next(
-                (
-                    _re.sub(r"^Go forward until the ", "", steps[j].strip())
-                    .strip()
-                    .rstrip(".")
-                    for j in range(i + 1, len(steps))
-                    if steps[j].strip().startswith("Go forward")
-                ),
-                None,
-            )
-            tp = position(nxt) if nxt else None
-            if tp is None or cur_head is None:
-                turns.append(None)
-            else:
-                turns.append(_classify_turn(cur_head, tp - cur_pos, up_vec, up_ax))
-                cur_head = tp - cur_pos
-        i += 1
-    return turns
-
-
-# ==========================================================================================
-# POINT-CLOUD CLEANING + DISTANCE ANSWERS -- outlier removal, closest-distance queries. Merged
-# in from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def _sor(pts, k=16, std=2.0, cap=4000):
-    """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
-    mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
-    """
-    from scipy.spatial import cKDTree
-
-    if len(pts) < k + 2:
-        return pts
-    rs = np.random.RandomState(0)
-    points = pts if len(pts) <= cap else pts[rs.choice(len(pts), cap, False)]
-    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
-    md = d[:, 1:].mean(1)
-    return points[md <= md.mean() + std * md.std()]
-
-
-def _main_cluster(pts):
-    """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
-    object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
-    """
-    from scipy.spatial import cKDTree
-
-    if len(pts) < 30:
-        return pts
-    tree = cKDTree(pts)
-    nn, _ = tree.query(pts, k=2)
-    eps = 3.0 * float(np.median(nn[:, 1]))  # 3x median NN gap (data-derived)
-    pairs = tree.query_pairs(eps, output_type="ndarray")
-    if len(pairs) == 0:
-        return pts
-    parent = np.arange(len(pts))
-
-    def find(x):
-        r = x
-        while parent[r] != r:
-            r = parent[r]
-        while parent[x] != r:
-            parent[x], x = r, parent[x]
-        return r
-
-    for a, b in pairs:
-        ra, rb = find(int(a)), find(int(b))
-        if ra != rb:
-            parent[ra] = rb
-    roots = np.array([find(i) for i in range(len(pts))])
-    v, cnt = np.unique(roots, return_counts=True)
-    return pts[roots == v[cnt.argmax()]]
-
-
-def _clean(inst, cap=4000):
-    """Outlier removal self-calibrated from the pipeline's OWN per-object signals -- no universal constant,
-    no benchmark knob. Cached on the instance so the O(classes^2) distance table cleans each object once.
-      (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
-          object's OWN median confidence (data-derived cut);
-      (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
-    """
-    if inst.get("_cleanpts") is not None:
-        return inst["_cleanpts"]
-    pts = inst["pts"]
-    conf = inst.get("conf")
-    rs = np.random.RandomState(0)
-    if len(pts) > cap:
-        idx = rs.choice(len(pts), cap, False)
-        pts = pts[idx]
-        conf = conf[idx] if conf is not None else None
-    if conf is not None and len(conf) > 20:  # self-calibrating: object's OWN median
-        keep = conf >= np.median(conf)
-        if keep.sum() >= 10:
-            pts = pts[keep]
-    pts = _sor(pts, cap=cap)  # density outlier removal on the survivors
-    # NOTE: spatial de-bleeding (_main_cluster) was tried and REVERTED -- "largest cluster = the object" is
-    # not guaranteed; when an object's near edge splits off it drops the true closest part (overshoot). You
-    # cannot post-hoc recover the true object from a bleeding mask in 3D -- that needs better SOURCE masks.
-    inst["_cleanpts"] = pts
-    return pts
-
-
-def answer_closest_distance(instances_a, instances_b, k=4000):
-    """Closest distance between the two objects' point clouds ('closest point of each object'). Points are
-    cleaned by _clean (self-calibrated per-object confidence + density) then exact nearest-neighbor min via
-    KD-tree, so mask-bleed/speckle can't collapse the answer. NOTE: VSI's GT is box-to-box on CLEAN annotation
-    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
-    """
-    points_a = _clean(_rep(instances_a), cap=k)
-    points_b = _clean(_rep(instances_b), cap=k)
-    if len(points_a) == 0 or len(points_b) == 0:
-        return float("inf")
-    from scipy.spatial import cKDTree
-
-    if len(points_a) <= len(points_b):
-        d, _ = cKDTree(points_a).query(points_b, k=1, workers=KD_WORKERS)
-    else:
-        d, _ = cKDTree(points_b).query(points_a, k=1, workers=KD_WORKERS)
-    return float(d.min())
-
-
-# ==========================================================================================
-# MASK/DEPTH CLEANUP + BACK-PROJECTION -- per-frame refinement before points enter an
-# instance's point cloud. Merged in from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def depth_edges(depth_f, valid_f):
-    """Per-frame depth-DISCONTINUITY map: gradient magnitude above median + 3*MAD over the valid pixels.
-    The threshold is data-derived (robust, universal statistical cut -- NOT benchmark-tuned). These edges are
-    where mask-bleed crosses onto an adjacent object at a different depth."""
-    if valid_f.sum() < 100:
-        return np.zeros_like(depth_f, bool)
-    d = np.where(valid_f, depth_f, np.median(depth_f[valid_f]))
-    gy, gx = np.gradient(d)
-    grad = np.hypot(gx, gy)
-    g = grad[valid_f]
-    med = np.median(g)
-    mad = np.median(np.abs(g - med)) + 1e-9
-    return (grad > med + 3.0 * 1.4826 * mad) & valid_f
-
-
-try:
-    _GUIDED = (
-        cv2.ximgproc.guidedFilter
-    )  # opencv-contrib; appearance-guided boundary snap
-except AttributeError:
-    _GUIDED = None
-
-
-def refine_mask(mask, rgb):
-    """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
-    bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
-    cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
-    """
-    if mask.shape[:2] != rgb.shape[:2]:
-        mask = cv2.resize(
-            mask.astype(np.uint8),
-            (rgb.shape[1], rgb.shape[0]),
-            interpolation=cv2.INTER_NEAREST,
-        ).astype(bool)
-    a = int(mask.sum())
-    if a < 60:  # too small to refine meaningfully -> 1px erode as before
-        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
-        return me if me.any() else mask
-    if _GUIDED is not None:
-        r = max(
-            4, int(round(0.02 * float(np.hypot(*mask.shape[:2]))))
-        )  # radius ~2% of frame diagonal
-        eps = (
-            float(np.var(rgb.astype(np.float32) / 255.0)) * 0.01 + 1e-6
-        )  # smoothness ~ image color variance
-        soft = _GUIDED(rgb, mask.astype(np.float32), r, eps)
-        out = soft > 0.5
-        return out if out.sum() >= 0.4 * a else mask  # majority guard: don't over-carve
-    # fallback (base opencv, no ximgproc): grabCut seeded FG=mask, PR_FG=dilated ring, BG=far exterior
-    try:
-        gc = np.full(mask.shape[:2], cv2.GC_PR_BGD, np.uint8)
-        dil = cv2.dilate(mask.astype(np.uint8), np.ones((15, 15), np.uint8), 1).astype(
-            bool
-        )
-        er = cv2.erode(mask.astype(np.uint8), np.ones((5, 5), np.uint8), 1).astype(bool)
-        gc[dil] = cv2.GC_PR_FGD
-        gc[er] = cv2.GC_FGD
-        bgm = np.zeros((1, 65), np.float64)
-        fgm = np.zeros((1, 65), np.float64)
-        cv2.grabCut(rgb, gc, None, bgm, fgm, 3, cv2.GC_INIT_WITH_MASK)
-        out = (gc == cv2.GC_FGD) | (gc == cv2.GC_PR_FGD)
-        return out if 0.4 * a <= out.sum() <= 1.5 * a else mask
-    except Exception:
-        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
-        return me if me.any() else mask
-
-
-def backproject_frame(
-    depth_f,
-    intrinsics,
-    c2w_f,
-    mask_f,
-    conf_f=None,
-    conf_thr=0.0,
-    valid_f=None,
-    return_conf=False,
-    edges_f=None,
-):
-    """Return (M,3) world points for the masked pixels of one frame (c2w_f = cam->world 4x4).
-    valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
-    return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
-    edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
-    """
-    height, width = depth_f.shape
-    empty = (
-        (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
-        if return_conf
-        else np.empty((0, 3), np.float32)
-    )
-    if mask_f.shape != (height, width):
-        mask_f = cv2.resize(
-            mask_f.astype(np.uint8), (width, height), interpolation=cv2.INTER_NEAREST
-        ).astype(bool)
-    if valid_f is None:
-        valid_f = np.isfinite(depth_f) & (depth_f > 0)
-    m = mask_f & valid_f
-    if conf_f is not None and conf_thr > 0:
-        m &= conf_f >= conf_thr
-    if (
-        edges_f is not None and m.sum() >= 30
-    ):  # keep the largest depth-coherent piece of the mask
-        from scipy import ndimage
-
-        lab, nlab = ndimage.label(m & ~edges_f)
-        if nlab >= 1:
-            sizes = np.bincount(lab.ravel())
-            sizes[0] = 0
-            big = int(sizes.argmax())
-            if (
-                sizes[big] >= 0.5 * m.sum()
-            ):  # object is the MAJORITY piece (bleed is a minority)
-                m = lab == big
-    if not m.any():
-        return empty
-    ys, xs = np.nonzero(m)
-    z = depth_f[ys, xs]
-    if DEPTH_COHERENCE and len(z) >= 8:
-        # an object is a coherent depth surface; floor/background BLEED pixels are depth outliers.
-        # Drop them via the standard Tukey fence (1.5*IQR) on the masked region's depths -- parameter-free.
-        q1, q3 = np.percentile(z, [25, 75])
-        iqr = q3 - q1
-        keep = (z >= q1 - 1.5 * iqr) & (z <= q3 + 1.5 * iqr)
-        if keep.sum() >= 1:
-            ys, xs, z = ys[keep], xs[keep], z[keep]
-    fx, fy, cx, cy = (
-        intrinsics[0, 0],
-        intrinsics[1, 1],
-        intrinsics[0, 2],
-        intrinsics[1, 2],
-    )
-    camera_points = np.stack(
-        [(xs - cx) * z / fx, (ys - cy) * z / fy, z], axis=1
-    )  # camera coords
-    world_points = (c2w_f[:3, :3] @ camera_points.T).T + c2w_f[:3, 3]  # -> world
-    if return_conf:
-        cw = (
-            conf_f[ys, xs].astype(np.float32)
-            if conf_f is not None
-            else np.ones(len(ys), np.float32)
-        )
-        return world_points.astype(np.float32), cw
-    return world_points.astype(np.float32)
-
-
-# ==========================================================================================
-# INSTANCE BUILDING -- oriented extent, 3D box-overlap re-identification, and the main
-# build_instances() driver that turns per-frame masks into per-class 3D instances. Merged in
-# from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def robust_centroid_extent(pts, up_axis=None):
-    """median centroid + ORIENTED robust extent.
-    If up_axis is given: YAW-ONLY oriented extent -- rotation is found by 2D PCA on the
-    floor-projected points only, with the up axis left untouched. This matches VSI-Bench's
-    own annotation convention for indoor scans (ScanNet/ARKitScenes OrientedBoundingBox
-    objects follow a Manhattan-world assumption: rotated only around the vertical axis,
-    never tilted). Unconstrained 3D PCA (the previous behavior) can chase noise on the
-    vertical axis for flat/elongated objects and drift away from the true yaw.
-    If up_axis is None (unknown at the call site): falls back to unconstrained 3D PCA.
-    Either way: parameter-free, rotation-invariant in-plane, p2..p98 robust extent."""
-    c = np.median(pts, axis=0)
-    centered = pts - c
-    if len(centered) > 5000:  # PCA on a sample (deterministic)
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    if up_axis is not None:
-        floor_axes = [i for i in range(3) if i != up_axis]
-        floor_points = centered[:, floor_axes]
-        try:
-            _, _, floor_rotation = np.linalg.svd(
-                floor_points - floor_points.mean(0), full_matrices=False
-            )
-            proj_floor = (
-                floor_points @ floor_rotation.T
-            )  # (N,2) along the object's own floor-plane axes
-        except np.linalg.LinAlgError:
-            proj_floor = floor_points
-        up_col = centered[:, up_axis : up_axis + 1]  # up axis untouched (yaw-only)
-        proj = np.concatenate([proj_floor, up_col], axis=1)
-    else:
-        try:
-            _, _, rotation = np.linalg.svd(
-                centered - centered.mean(0), full_matrices=False
-            )
-            proj = centered @ rotation.T  # coordinates along principal axes
-        except np.linalg.LinAlgError:
-            proj = centered
-    lo = np.percentile(proj, 2, axis=0)
-    hi = np.percentile(proj, 98, axis=0)
-    ext = np.maximum(hi - lo, 0.0)
-    dims = np.sort(ext)[::-1]  # the object's 3 oriented side lengths, longest first
-    return c.astype(np.float32), float(dims[0]), dims
-
-
-def _aabb(pts):
-    """robust (p2..p98) axis-aligned 3D box of an instance's world points."""
-    return np.percentile(pts, 2, axis=0), np.percentile(pts, 98, axis=0)
-
-
-def merge_by_box_overlap(insts, up_axis=None):
-    """Parameter-free 3D re-identification, with a temporal-exclusion gate.
-
-    SAM3 (a 2D tracker) emits a NEW masklet each time the camera revisits an object, so one
-    physical object -> several masklets at the same 3D location. We fuse two same-class masklets
-    iff BOTH:
-      (a) their measured 3D boxes overlap (or one centroid is inside the other) -- same volume, and
-      (b) they NEVER appear in the same frame -- temporal exclusion.
-    (b) is the key parameter-free invariant: two masklets co-visible in one frame were tracked by
-    SAM3 as distinct objects in that frame, so they ARE distinct (e.g. two chairs around a table);
-    we must never merge them, even if depth noise makes their boxes overlap. A revisit-duplicate,
-    by contrast, lives in DISJOINT frames. Both tests are exact/measured -- NO tuned threshold.
-    """
-    n = len(insts)
-    if n <= 1:
-        return insts
-    # Precompute the FULL pairwise box-match as one vectorized boolean matrix. With the per-frame
-    # batched detector a class can have 100+ raw instances; the old O(n^3) loop called np.all-based
-    # box_match millions of times. Here every pairwise test is one broadcast -> O(1) lookups below.
-    lo = np.stack([_aabb(i["pts"])[0] for i in insts]).astype(np.float32)  # (n,3)
-    hi = np.stack([_aabb(i["pts"])[1] for i in insts]).astype(np.float32)  # (n,3)
-    cents = np.stack([i["centroid"] for i in insts]).astype(np.float32)  # (n,3)
-    overlap = (hi[:, None, :] >= lo[None, :, :]).all(-1) & (
-        hi[None, :, :] >= lo[:, None, :]
-    ).all(-1)
-    ins = (cents[:, None, :] >= lo[None, :, :]).all(-1) & (
-        cents[:, None, :] <= hi[None, :, :]
-    ).all(-1)
-    match = (
-        overlap | ins | ins.T
-    )  # box_match[i,j]: same 3D volume (identical semantics to old code)
-    # group-level agglomeration: merge two groups only if their COMBINED frame sets are disjoint
-    # (so no two co-visible masklets ever land in one object) AND some cross-pair shares a 3D volume.
-    groups = [
-        {"members": [i], "frames": set(insts[i].get("frames", set()))} for i in range(n)
-    ]
-    changed = True
-    while changed:
-        changed = False
-        for a in range(len(groups)):
-            for b in range(a + 1, len(groups)):
-                if (
-                    groups[a]["frames"] & groups[b]["frames"]
-                ):  # co-visible -> distinct objects
-                    continue
-                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
-                    groups[a]["members"] += groups[b]["members"]
-                    groups[a]["frames"] |= groups[b]["frames"]
-                    groups.pop(b)
-                    changed = True
-                    break
-            if changed:
-                break
-    merged = []
-    for g in groups:
-        idxs = g["members"]
-        pts = np.concatenate([insts[k]["pts"] for k in idxs], 0)
-        cpts = np.concatenate(
-            [
-                insts[k].get("conf", np.ones(len(insts[k]["pts"]), np.float32))
-                for k in idxs
-            ],
-            0,
-        )
-        best = max(
-            (insts[k]["best_pts"] for k in idxs), key=len
-        )  # largest single obs in the group
-        c, longest, dims = robust_centroid_extent(
-            best, up_axis
-        )  # size+pos+3 oriented dims from best view (#2/#4)
-        merged.append(
-            {
-                "centroid": c,
-                "size": longest,
-                "dims": dims,
-                "first_time": min(insts[k]["first_time"] for k in idxs),
-                "pts": pts,
-                "conf": cpts,
-                "best_pts": best,
-                "observations": [
-                    observation
-                    for k in idxs
-                    for observation in insts[k].get("observations", [insts[k]["pts"]])
-                ],
-                "frames": g["frames"],
-                "n": sum(insts[k]["n"] for k in idxs),
-                "nframes": len(g["frames"]),
-                "oids": [oid for k in idxs for oid in insts[k].get("oids", [])],
-            }
-        )  # track persistence (evidence strength)
-    return merged
-
-
-def build_instances(
-    per_class, depth, intr, c2w, conf, frame_times, frame_paths=None, up_axis=None
-):
-    """-> {class: [ {centroid(3), size(longest dim), first_time, npts} ]}
-    up_axis: if known (from room_gravity, computed BEFORE this call), threads through to
-    robust_centroid_extent for yaw-only oriented sizing. If None, size falls back to
-    unconstrained 3D PCA."""
-    out = {}
-    stats = {}
-    nframes = len(depth)
-    # precompute each frame's valid-depth mask ONCE (was recomputed per mask -> per class).
-    valid = {}
-    edges = {}
-    rgb = {}
-    used_frames = {fi for frames in per_class.values() for fi in frames if fi < nframes}
-    for fi in used_frames:
-        valid[fi] = np.isfinite(depth[fi]) & (depth[fi] > 0)
-        edges[fi] = depth_edges(depth[fi], valid[fi]) if DEPTH_EDGE_REFINE else None
-        if MASK_REFINE and frame_paths and fi < len(frame_paths):
-            im = cv2.imread(frame_paths[fi])  # BGR; guidedFilter/grabCut want 3ch uint8
-            rgb[fi] = (
-                cv2.resize(im, (depth[fi].shape[1], depth[fi].shape[0]))
-                if im is not None
-                else None
-            )
-    for cls, frames in per_class.items():
-        # peak co-visibility: max distinct masklets SAM3 tracks SIMULTANEOUSLY in any one frame.
-        # geometry-free, parameter-free, immune to revisit over-count; provable lower bound on count.
-        peak = max((len(objs) for objs in frames.values()), default=0)
-        # gather world points + first-seen time + frame set per obj_id (SAM3 track id = masklet)
-        pts_by_id, conf_by_id, first_t, frames_by_id = {}, {}, {}, {}
-        # px_by_id: (fidx, frame_time, mask_pixel_count) per obj_id, for appearance-order timing.
-        # VSI-Bench's own GT defines "first appearance" as the timestamp where an object's pixel
-        # count crosses a threshold (paper appendix B.1) -- NOT the first frame with any pixel at
-        # all. A single stray mask-bleed/false-positive pixel would otherwise register as "first
-        # seen" far too early. The threshold is self-calibrated per instance (that instance's OWN
-        # median observed pixel count across its frames), same convention as _clean's median cut.
-        px_by_id = {}
-        for fidx, objs in frames.items():
-            if fidx >= nframes:  # guard: SAM3 frame idx vs DA3 frames
-                continue
-            for oid, mask in objs.items():
-                if MASK_REFINE and rgb.get(fidx) is not None:
-                    me = (
-                        mask
-                        if os.environ.get("VSI_NO_REFINE") == "1"
-                        else refine_mask(mask, rgb[fidx])
-                    )  # appearance-guided boundary snap (clips same-depth bleed)
-                else:
-                    # erode 1px to drop mask-edge / background depth bleed
-                    me = cv2.erode(
-                        mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1
-                    ).astype(bool)
-                    if not me.any():
-                        me = mask
-                conf_f = conf[fidx] if conf is not None else None
-                conf_thr = (
-                    np.percentile(conf_f, CONF_PCT)
-                    if (conf_f is not None and CONF_PCT > 0)
-                    else 0.0
-                )
-                world_points, cw = backproject_frame(
-                    depth[fidx],
-                    intr[fidx],
-                    c2w[fidx],
-                    me,
-                    conf_f,
-                    conf_thr=conf_thr,
-                    valid_f=valid.get(fidx),
-                    return_conf=True,
-                    edges_f=edges.get(fidx),
-                )
-                if len(world_points):
-                    pts_by_id.setdefault(oid, []).append(world_points)
-                    conf_by_id.setdefault(oid, []).append(
-                        cw
-                    )  # per-point DA3 confidence (for _clean)
-                    frames_by_id.setdefault(oid, set()).add(
-                        fidx
-                    )  # for co-occurrence gate
-                    t = frame_times[fidx]
-                    px_by_id.setdefault(oid, []).append((fidx, t, int(me.sum())))
-        # appearance_order timing: per instance, first frame at/above its OWN median pixel count
-        for oid, obs in px_by_id.items():
-            counts = [c for _, _, c in obs]
-            thresh = float(np.median(counts))
-            crossing = [t for _, t, c in obs if c >= thresh]
-            first_t[oid] = min(crossing) if crossing else min(t for _, t, c in obs)
-        insts = []
-        for oid, plist in pts_by_id.items():
-            pts = np.concatenate(plist, 0)
-            cpts = np.concatenate(conf_by_id[oid], 0)
-            if len(pts) < MIN_INSTANCE_PTS:
-                continue
-            best = max(
-                plist, key=len
-            )  # #2/#4: largest single-frame observation (closest/most pixels)
-            bc, bsize, bdims = robust_centroid_extent(
-                best, up_axis
-            )  # size + position + 3 oriented dims from best view
-            insts.append(
-                {
-                    "centroid": bc,
-                    "size": bsize,
-                    "dims": bdims,
-                    "first_time": first_t[oid],
-                    "pts": pts,
-                    "conf": cpts,
-                    "best_pts": best,
-                    "observations": list(plist),
-                    "n": len(pts),
-                    "frames": frames_by_id[oid],
-                    # Raw SAM3 masklet id this fragment came from -- carried through every
-                    # later merge/consolidation step (never emitted in the JSON schema) so
-                    # a strong-correspondence overlay can draw SAM3's OWN per-frame
-                    # box/mask for a code instance instead of re-deriving one via 3D
-                    # projection. See encoder.geometric.instance_source_track_ids.
-                    "oids": [int(oid)],
-                }
-            )
-        raw = len(insts)
-        # 3D re-ID: fuse same-class masklets that occupy the same measured 3D volume (parameter-free).
-        insts = merge_by_box_overlap(insts, up_axis)
-        if insts:
-            out[cls] = insts
-            stats[cls] = {"raw": raw, "merged": len(insts), "peak": peak}
-    return out, stats
-
-
-# ==========================================================================================
-# PER-CLASS SUMMARY -- legacy array-schema row builder. Merged in from perceptual.py, verbatim.
-# (The room-scale floor area calculation that used to live here is gone -- the explicit
-# schema's floor area is now a direct derivation of the compact schema's floor boundary
-# polygons; see build_explicit_spatial_code() near build_compact_spatial_code().)
-# ==========================================================================================
-
-
-# ---- Per-class spatial code (legacy array-schema row) -------------------------------------
-def class_spatial_code(insts, peak=0):
-    cents = np.stack([i["centroid"] for i in insts], 0)  # (n,3)
-    sizes = np.array([i["size"] for i in insts], np.float32)
-    n = len(insts)  # merged centroids (for spatial stats)
-    count = peak if peak else n  # reported count = peak co-visibility
-    x, y, z = cents.mean(0)
-    if n == 1:
-        e1 = e2 = e3 = px = pz = 0.0
-        size_iqr = 0.0
-    else:
-        cov = np.cov(cents.T)  # 3x3
-        vals, vecs = np.linalg.eigh(cov)  # ascending
-        order = np.argsort(vals)[::-1]
-        vals = np.clip(vals[order], 0, None)
-        vecs = vecs[:, order]
-        e1, e2, e3 = vals.tolist()
-        pv = vecs[:, 0]  # principal eigenvector
-        px, pz = float(pv[0]), float(pv[2])
-        q1, q3 = np.percentile(sizes, [25, 75])
-        size_iqr = float(q3 - q1)
-    size_median = float(np.median(sizes))
-    first_time = float(min(i["first_time"] for i in insts))
-    row = [x, y, z, e1, e2, e3, px, pz, size_median, size_iqr, first_time, count]
-    row = [
-        (lambda r: 0.0 if r == 0 else r)(round(float(v), 1)) for v in row
-    ]  # kill -0.0
-    row[-1] = int(count)
-    return row
-
-
-def _reference_object_records(insts, count, u, v, g, floor_level):
-    """Object record formatter used by the original V2 spatial-code builder."""
-    ranked = sorted(insts, key=lambda i: (i["n"], i.get("nframes", 0)), reverse=True)[
-        : max(int(count), 1)
-    ]
-    recs = []
-    for it in ranked:
-        center = np.asarray(it["centroid"], np.float64)
-        points = np.asarray(it["pts"], np.float64)
-        floor_x = points @ u
-        floor_y = points @ v
-        height = points @ g - floor_level
-        recs.append(
-            {
-                "position": {
-                    "floor_x_meters": round(float(center @ u), 2),
-                    "floor_y_meters": round(float(center @ v), 2),
-                    "height_above_floor_meters": round(
-                        float(center @ g - floor_level), 2
-                    ),
-                },
-                "longest_dimension_meters": round(float(it["size"]), 2),
-                "bounding_box": {
-                    "floor_x_meters": [
-                        round(float(np.percentile(floor_x, 2)), 2),
-                        round(float(np.percentile(floor_x, 98)), 2),
-                    ],
-                    "floor_y_meters": [
-                        round(float(np.percentile(floor_y, 2)), 2),
-                        round(float(np.percentile(floor_y, 98)), 2),
-                    ],
-                    "height_above_floor_meters": [
-                        round(float(np.percentile(height, 2)), 2),
-                        round(float(np.percentile(height, 98)), 2),
-                    ],
-                },
-                "dimensions_meters": [round(float(d), 2) for d in it["dims"]],
-            }
-        )
-    return recs
-
-
-def _reference_to_spatial_code(
-    instances, stats, floor_area, up_axis, up_vec, floor_level
-):
-    """Per-instance spatial code shape from the original geometric V2 pipeline."""
-    u, v, g = _floor_basis(up_vec)
-    out = {"objects": {}}
-    for class_name, insts in instances.items():
-        count = int(stats[class_name]["peak"])
-        out["objects"][class_name] = {
-            "count": count,
-            "instances": _reference_object_records(insts, count, u, v, g, floor_level),
-        }
-    out["room"] = {"floor_area_square_meters": floor_area}
-    return out
-
-
-def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
-    """Reference floor-area computation from the original geometric pipeline."""
-    points = []
-    for frame_index in range(depth.shape[0]):
-        height, width = depth[frame_index].shape
-        rows, columns = np.mgrid[0:height:stride, 0:width:stride]
-        rows = rows.ravel()
-        columns = columns.ravel()
-        values = depth[frame_index][rows, columns]
-        keep = np.isfinite(values) & (values > 0)
-        if sky is not None:
-            keep &= ~sky[frame_index][rows, columns].astype(bool)
-        if conf is not None:
-            keep &= conf[frame_index][rows, columns] >= np.percentile(
-                conf[frame_index], 40
-            )
-        rows, columns, values = rows[keep], columns[keep], values[keep]
-        if not len(values):
-            continue
-        current = intr[frame_index]
-        camera = np.stack(
-            [
-                (columns - current[0, 2]) * values / current[0, 0],
-                (rows - current[1, 2]) * values / current[1, 1],
-                values,
-            ],
-            1,
-        )
-        world = (c2w[frame_index][:3, :3] @ camera.T).T + c2w[frame_index][:3, 3]
-        points.append(world.astype(np.float32))
-    if not points:
-        return 0.0
-    scene_points = np.concatenate(points, 0)
-    if up_vec is not None:
-        gravity = np.asarray(up_vec, np.float64)
-        gravity /= np.linalg.norm(gravity) + 1e-12
-        axis = (
-            np.array([1.0, 0.0, 0.0])
-            if abs(gravity[0]) < 0.9
-            else np.array([0.0, 1.0, 0.0])
-        )
-        u = np.cross(gravity, axis)
-        u /= np.linalg.norm(u)
-        v = np.cross(gravity, u)
-        floor_points = np.stack([scene_points @ u, scene_points @ v], 1)
-    else:
-        up_axis = int(np.argmin(scene_points.max(0) - scene_points.min(0)))
-        floor_axes = [axis for axis in range(3) if axis != up_axis]
-        floor_points = scene_points[:, floor_axes]
-    lower = np.percentile(floor_points, 0.5, 0)
-    upper = np.percentile(floor_points, 99.5, 0)
-    floor_points = floor_points[
-        (floor_points[:, 0] >= lower[0])
-        & (floor_points[:, 0] <= upper[0])
-        & (floor_points[:, 1] >= lower[1])
-        & (floor_points[:, 1] <= upper[1])
-    ]
-    if len(floor_points) < 10:
-        return 0.0
-    try:
-        import alphashape
-
-        sample = np.random.RandomState(0).choice(
-            len(floor_points), min(10000, len(floor_points))
-        )
-        return round(
-            float(alphashape.alphashape(floor_points[sample], alpha=2).area), 1
-        )
-    except Exception:
-        from scipy import ndimage
-
-        resolution = 0.10
-        rows = ((floor_points[:, 0] - floor_points[:, 0].min()) / resolution).astype(
-            int
-        )
-        columns = ((floor_points[:, 1] - floor_points[:, 1].min()) / resolution).astype(
-            int
-        )
-        grid = np.zeros((rows.max() + 3, columns.max() + 3), np.uint8)
-        grid[rows + 1, columns + 1] = 1
-        grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-        grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-        return round(float(grid.sum()) * resolution * resolution, 1)
-
-
-# ---------------------------------------------------------------------------
-
-# ==========================================================================================
-# SPATIAL CODE ASSEMBLY -- the top-level entry point this whole file exists for:
-# build_spatial_code() calls everything above to turn already-computed depth/pose/masks into
-# the final spatial code dict. Room outline + JSON writer. This section was already in
-# geometric.py before the perceptual.py merge; build_spatial_code() below is updated to call
-# the geometry functions above DIRECTLY (no `pl.` prefix -- they're plain local functions now
-# that everything is in one file), same logic, unchanged otherwise.
-# ==========================================================================================
-
-
-def _room_outline(depth, intr, c2w, conf, bu, bv):
-    """(Unemitted by explicit format; compact format derives its boundary separately. This
-    math is kept intact for reuse.) Room floor-boundary polygon from the SAME grid as
-    compute_floor_area: floor points
-    projected onto the shared gravity plane (bu, bv), 10cm grid, close 7x7, fill holes,
-    largest contour, 0.2m polygon simplification. Same (bu, bv) as objects/camera, so the
-    outline, object positions, and floor_area all live in one consistent frame."""
-    from scipy import ndimage
-
-    pts, stride = [], 8
-    for f in range(0, depth.shape[0], 3):
-        height, width = depth[f].shape
-        ys, xs = np.mgrid[0:height:stride, 0:width:stride]
-        ys = ys.ravel()
-        xs = xs.ravel()
-        z = depth[f][ys, xs]
-        ok = np.isfinite(z) & (z > 0)
-        if conf is not None:
-            ok &= conf[f][ys, xs] >= np.percentile(conf[f], 40)
-        ys, xs, z = ys[ok], xs[ok], z[ok]
-        if not len(z):
-            continue
-        intrinsics = intr[f]
-        camera_points = np.stack(
-            [
-                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
-                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
-                z,
-            ],
-            1,
-        )
-        pts.append(
-            ((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3]).astype(np.float32)
-        )
-    if not pts:
-        return []
-    world_points = np.concatenate(pts, 0)
-    points = np.stack(
-        [world_points @ bu, world_points @ bv], 1
-    )  # gravity-plane projection (same bu,bv as objects/area)
-    lo = np.percentile(points, 0.5, 0)
-    hi = np.percentile(points, 99.5, 0)
-    points = points[
-        (points[:, 0] >= lo[0])
-        & (points[:, 0] <= hi[0])
-        & (points[:, 1] >= lo[1])
-        & (points[:, 1] <= hi[1])
-    ]
-    if len(points) < 10:
-        return []
-    res = 0.10
-    x0, y0 = points[:, 0].min(), points[:, 1].min()
-    ai = ((points[:, 0] - x0) / res).astype(int)
-    bi = ((points[:, 1] - y0) / res).astype(int)
-    grid = np.zeros((ai.max() + 3, bi.max() + 3), np.uint8)
-    grid[ai + 1, bi + 1] = 1
-    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-    cs, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not cs:
-        return []
-    poly = cv2.approxPolyDP(max(cs, key=cv2.contourArea), 0.2 / res, True)[:, 0, :]
-    # cv2 contour points are (col=bi, row=ai) -> (floor_y, floor_x)
-    return [
-        {
-            "floor_x_meters": round(float((r - 1) * res + x0), 1),
-            "floor_y_meters": round(float((c - 1) * res + y0), 1),
-        }
-        for c, r in poly
-    ]
-
-
-def dump_spatial_code(code, path):
-    """Save a spatial_code.json exactly like json.dump(code, f, indent=1), EXCEPT
-    "appearance order" is written as one compact line instead of one line per entry -- it's a
-    single ordered sequence meant to be scanned, not structured data meant to be read field by
-    field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
-    """
-    body = dict(code)
-    ao = body.pop("appearance order", None)
-    text = json.dumps(body, indent=1).rstrip()
-    if ao is not None:
-        assert text.endswith("}")
-        text = text[:-1].rstrip() + ',\n "appearance order": ' + json.dumps(ao) + "\n}"
-    with open(path, "w") as f:
-        f.write(text)
-
-
-# Canonical world-space fallback used by SegVGGT and similar adapters.
-def _canonical_room_gravity(points, cameras=None, iters=300, thr=0.05):
-    """Robust UP vector = normal of the RANSAC floor plane, oriented toward the cameras."""
-    points = np.asarray(points, np.float64)
-    points = points[np.isfinite(points).all(1)]
-    if len(points) > 100000:
-        points = points[np.random.RandomState(0).choice(len(points), 100000, False)]
-    cam = (
-        np.asarray(cameras, np.float64).mean(0)
-        if cameras is not None and len(cameras)
-        else None
-    )
-    if len(points) < 100:
-        ext = (
-            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-            if len(points)
-            else np.ones(3)
-        )
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return (g, ax)
-    rng = np.random.RandomState(0)
-    best = None
-    best_score = -1
-    for _ in range(iters):
-        a, b, c = points[rng.choice(len(points), 3, False)]
-        nrm = np.cross(b - a, c - a)
-        ln = np.linalg.norm(nrm)
-        if ln < 1e-06:
-            continue
-        nrm /= ln
-        d = -nrm @ a
-        side = points @ nrm + d
-        ninl = int((np.abs(side) < thr).sum())
-        if ninl < 50:
-            continue
-        score = ninl * max(np.mean(side > thr), np.mean(side < -thr))
-        if score > best_score:
-            best_score = score
-            best = (nrm, d)
-    if best is None:
-        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return (g, ax)
-    nrm, d = best
-    if cam is not None and cam @ nrm + d < 0:
-        nrm = -nrm
-    return (nrm.astype(np.float32), int(np.argmax(np.abs(nrm))))
-
-
-def _canonical_floor_basis(up_vec):
-    """Orthonormal floor basis (u, v horizontal; g = up), unchanged from the old file."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-    up_ax = int(np.argmax(np.abs(g)))
-    floor_axes = [a for a in range(3) if a != up_ax]
-    e0 = np.zeros(3)
-    e0[floor_axes[0]] = 1.0
-    u = e0 - e0 @ g * g
-    u = u / (np.linalg.norm(u) + 1e-12)
-    v = np.cross(g, u)
-    if v[floor_axes[1]] < 0:
-        v = -v
-    return (u, v, g)
-
-
-def _canonical_robust_centroid_extent(pts, up_axis=None):
-    c = np.median(pts, axis=0)
-    centered = pts - c
-    if len(centered) > 5000:
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    if up_axis is not None:
-        floor_axes = [i for i in range(3) if i != up_axis]
-        floor_points = centered[:, floor_axes]
-        try:
-            _, _, floor_rotation = np.linalg.svd(
-                floor_points - floor_points.mean(0), full_matrices=False
-            )
-            proj_floor = floor_points @ floor_rotation.T
-        except np.linalg.LinAlgError:
-            proj_floor = floor_points
-        proj = np.concatenate([proj_floor, centered[:, up_axis : up_axis + 1]], 1)
-    else:
-        try:
-            _, _, rotation = np.linalg.svd(
-                centered - centered.mean(0), full_matrices=False
-            )
-            proj = centered @ rotation.T
-        except np.linalg.LinAlgError:
-            proj = centered
-    ext = np.maximum(np.percentile(proj, 98, 0) - np.percentile(proj, 2, 0), 0.0)
-    dims = np.sort(ext)[::-1]
-    return (c.astype(np.float32), float(dims[0]), dims)
-
-
-def _canonical_aabb(pts):
-    return (np.percentile(pts, 2, 0), np.percentile(pts, 98, 0))
-
-
-def _canonical_merge_by_box_overlap(insts, up_axis=None):
-    """Parameter-free 3D re-identification with temporal exclusion, unchanged."""
-    n = len(insts)
-    if n <= 1:
-        return insts
-    lo = np.stack([_canonical_aabb(i["pts"])[0] for i in insts])
-    hi = np.stack([_canonical_aabb(i["pts"])[1] for i in insts])
-    cents = np.stack([i["centroid"] for i in insts])
-    overlap = (hi[:, None] >= lo[None]).all(-1) & (hi[None] >= lo[:, None]).all(-1)
-    ins = (cents[:, None] >= lo[None]).all(-1) & (cents[:, None] <= hi[None]).all(-1)
-    match = overlap | ins | ins.T
-    groups = [
-        {"members": [i], "frames": set(insts[i].get("frames", ()))} for i in range(n)
-    ]
-    changed = True
-    while changed:
-        changed = False
-        for a in range(len(groups)):
-            for b in range(a + 1, len(groups)):
-                if groups[a]["frames"] & groups[b]["frames"]:
-                    continue
-                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
-                    groups[a]["members"] += groups[b]["members"]
-                    groups[a]["frames"] |= groups[b]["frames"]
-                    groups.pop(b)
-                    changed = True
-                    break
-            if changed:
-                break
-    out = []
-    for g in groups:
-        ii = g["members"]
-        pts = np.concatenate([insts[k]["pts"] for k in ii], 0)
-        best = max((insts[k]["best_pts"] for k in ii), key=len)
-        c, size, dims = _canonical_robust_centroid_extent(best, up_axis)
-        confs = [insts[k].get("conf") for k in ii]
-        conf = (
-            np.concatenate([x for x in confs if x is not None], 0)
-            if any((x is not None for x in confs))
-            else None
-        )
-        out.append(
-            {
-                "centroid": c,
-                "size": size,
-                "dims": dims,
-                "pts": pts,
-                "best_pts": best,
-                "observations": [
-                    observation
-                    for k in ii
-                    for observation in insts[k].get("observations", [insts[k]["pts"]])
-                ],
-                "conf": conf,
-                "frames": g["frames"],
-                "nframes": len(g["frames"]),
-                "n": sum((insts[k]["n"] for k in ii)),
-                "first_time": min((insts[k]["first_time"] for k in ii)),
-            }
-        )
-    return out
-
-
-def _canonical_sor(pts, k=16, std=2.0, cap=4000):
-    from scipy.spatial import cKDTree
-
-    if len(pts) < k + 2:
-        return pts
-    points = (
-        pts
-        if len(pts) <= cap
-        else pts[np.random.RandomState(0).choice(len(pts), cap, False)]
-    )
-    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
-    md = d[:, 1:].mean(1)
-    return points[md <= md.mean() + std * md.std()]
-
-
-def _canonical_clean(inst, cap=4000):
-    if inst.get("_cleanpts") is not None:
-        return inst["_cleanpts"]
-    pts, conf = (inst["pts"], inst.get("conf"))
-    if len(pts) > cap:
-        idx = np.random.RandomState(0).choice(len(pts), cap, False)
-        pts = pts[idx]
-        if conf is not None:
-            conf = conf[idx]
-    if conf is not None and len(conf) > 20:
-        keep = conf >= np.median(conf)
-        if keep.sum() >= 10:
-            pts = pts[keep]
-    inst["_cleanpts"] = _canonical_sor(pts, cap=cap)
-    return inst["_cleanpts"]
-
-
-# ==========================================================================================
-# COMPACT SPATIAL CODE -- reusable geometry and time primitives, with no derived answers.
-# ==========================================================================================
-
-
-COMPACT_SPATIAL_CODE_SCHEMA = {
-    "objects": {
-        "<object class>": [
-            {
-                "3D oriented bounding box": {
-                    "3D oriented bounding box center coordinates": {
-                        "components": ["x", "y", "height above floor"],
-                        "unit": "meters",
-                        "description": (
-                            "center of the 3D oriented bounding box in the shared room "
-                            "coordinate system"
-                        ),
-                    },
-                    "3D oriented bounding box dimensions": {
-                        "components": ["dimension 1", "dimension 2", "dimension 3"],
-                        "unit": "meters",
-                        "description": (
-                            "full lengths of the 3D oriented bounding box along the "
-                            "corresponding orientation unit vectors"
-                        ),
-                    },
-                    "3D oriented bounding box orientation unit vectors": {
-                        "components": [
-                            ["x", "y", "height"],
-                            ["x", "y", "height"],
-                            ["x", "y", "height"],
-                        ],
-                        "unit": None,
-                        "description": (
-                            "three perpendicular directions corresponding in order to the "
-                            "three 3D oriented bounding box dimensions"
-                        ),
-                    },
-                },
-                "first visible time": {
-                    "unit": "seconds",
-                    "description": (
-                        "earliest time at which this object instance is visibly observed"
-                    ),
-                },
-            }
-        ]
-    },
-    "room": {
-        "floor boundary polygons": [
-            {
-                "outer boundary coordinates": {
-                    "components": [["x", "y"], ["x", "y"]],
-                    "unit": "meters",
-                    "description": "ordered vertices enclosing one floor region",
-                },
-                "interior hole boundary coordinates": {
-                    "components": [[["x", "y"], ["x", "y"]]],
-                    "unit": "meters",
-                    "description": (
-                        "ordered boundaries enclosing regions excluded from the floor area"
-                    ),
-                },
-            }
-        ]
-    },
-}
-
-
-def _rounded_list(values):
-    """Round one numeric vector to stable JSON values without negative zero."""
-    return [0.0 if (value := round(float(x), 2)) == 0 else value for x in values]
-
-
-def _weighted_quantile(values, weights, quantile):
-    """Return one deterministic weighted quantile for observation consensus."""
-    values = np.asarray(values, np.float64)
-    weights = np.asarray(weights, np.float64)
-    order = np.argsort(values)
-    values, weights = values[order], weights[order]
-    cumulative = np.cumsum(weights) - 0.5 * weights
-    cumulative /= weights.sum()
-    return float(np.interp(quantile, cumulative, values))
-
-
-def _compact_oriented_box(instance, u, v, g, floor_level):
-    """Fit one floor-aligned OBB from the same per-instance math as the reference code."""
-    center = np.asarray(instance["centroid"], np.float64)
-    points = np.asarray(instance["best_pts"], np.float64)
-    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
-    centered = room_points[:, :2] - np.median(room_points[:, :2], axis=0)
-    if len(centered) > 5000:
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    try:
-        _, _, rotation = np.linalg.svd(
-            centered - centered.mean(axis=0), full_matrices=False
-        )
-    except np.linalg.LinAlgError:
-        rotation = np.eye(2)
-    first = rotation[0]
-    dominant = int(np.argmax(np.abs(first)))
-    if first[dominant] < 0:
-        first = -first
-    second = np.array([-first[1], first[0]])
-    orientation = np.array(
-        [[first[0], first[1], 0.0], [second[0], second[1], 0.0], [0.0, 0.0, 1.0]]
-    )
-    box_center = np.array([center @ u, center @ v, center @ g - floor_level])
-    box_dimensions = np.asarray(instance["dims"], np.float64)
-    return {
-        "3D oriented bounding box center coordinates": _rounded_list(box_center),
-        "3D oriented bounding box dimensions": _rounded_list(box_dimensions),
-        "3D oriented bounding box orientation unit vectors": [
-            _rounded_list(axis) for axis in orientation
-        ],
-    }
-
-
-def _contour_coordinates(contour, x_origin, y_origin, resolution):
-    """Translate one OpenCV grid contour to ordered shared-room coordinates."""
-    return [
-        _rounded_list(
-            [x_origin + (row - 1) * resolution, y_origin + (column - 1) * resolution]
-        )
-        for column, row in contour[:, 0, :]
-    ]
-
-
-def _compact_scene_points(scene):
-    """Return the same dense floor-support sample used by explicit room-area math."""
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is None:
-        return scene["scene_pts"]
-    depth = raw_inputs["depth"]
-    intrinsics = raw_inputs["intr"]
-    poses = raw_inputs["c2w"]
-    confidence = raw_inputs.get("conf")
-    points = []
-    for frame_index in range(len(depth)):
-        height, width = depth[frame_index].shape
-        rows, columns = np.mgrid[0:height:8, 0:width:8]
-        rows, columns = rows.ravel(), columns.ravel()
-        values = depth[frame_index][rows, columns]
-        keep = np.isfinite(values) & (values > 0)
-        if confidence is not None:
-            threshold = np.percentile(confidence[frame_index], 40)
-            keep &= confidence[frame_index][rows, columns] >= threshold
-        rows, columns, values = rows[keep], columns[keep], values[keep]
-        if not len(values):
-            continue
-        current = intrinsics[frame_index]
-        camera = np.stack(
-            [
-                (columns - current[0, 2]) * values / current[0, 0],
-                (rows - current[1, 2]) * values / current[1, 1],
-                values,
-            ],
-            axis=1,
-        )
-        world = poses[frame_index][:3, :3] @ camera.T
-        points.append((world.T + poses[frame_index][:3, 3]).astype(np.float32))
-    return np.concatenate(points, axis=0) if points else scene["scene_pts"]
-
-
-def _compact_floor_boundary_polygons(points, u, v, object_points=None):
-    """Extract the reference room outline as a compact floor-boundary polygon."""
-    from scipy import ndimage
-
-    points = np.asarray(points, np.float64)
-    floor_points = np.stack([points @ u, points @ v], axis=1)
-    floor_points = floor_points[np.isfinite(floor_points).all(axis=1)]
-    if len(floor_points) < 3:
-        return []
-    lower = np.percentile(floor_points, 0.5, axis=0)
-    upper = np.percentile(floor_points, 99.5, axis=0)
-    floor_points = floor_points[
-        (floor_points[:, 0] >= lower[0])
-        & (floor_points[:, 0] <= upper[0])
-        & (floor_points[:, 1] >= lower[1])
-        & (floor_points[:, 1] <= upper[1])
-    ]
-    if len(floor_points) < 3:
-        return []
-    resolution = 0.1
-    x_origin, y_origin = floor_points.min(axis=0)
-    x_max, y_max = floor_points.max(axis=0)
-    row_count = int((x_max - x_origin) / resolution) + 3
-    column_count = int((y_max - y_origin) / resolution) + 3
-    grid = np.zeros((row_count, column_count), np.uint8)
-    rows = ((floor_points[:, 0] - x_origin) / resolution).astype(int)
-    columns = ((floor_points[:, 1] - y_origin) / resolution).astype(int)
-    grid[rows + 1, columns + 1] = 1
-    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-    contours, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return []
-    contour = cv2.approxPolyDP(
-        max(contours, key=cv2.contourArea), 0.2 / resolution, True
-    )
-    return [
-        {
-            "outer boundary coordinates": _contour_coordinates(
-                contour, x_origin, y_origin, resolution
-            ),
-            "interior hole boundary coordinates": [],
-        }
-    ]
-
-
-def _compact_duplicate_groups(instances):
-    """Group near-identical co-visible boxes that represent duplicate mask tracks."""
-    count = len(instances)
-    parent = list(range(count))
-
-    def root(index):
-        while parent[index] != index:
-            parent[index] = parent[parent[index]]
-            index = parent[index]
-        return index
-
-    def union(first, second):
-        first, second = root(first), root(second)
-        if first != second:
-            parent[second] = first
-
-    bounds = [_canonical_aabb(_canonical_clean(instance)) for instance in instances]
-    for first in range(count):
-        lower_a, upper_a = bounds[first]
-        extent_a = np.maximum(upper_a - lower_a, 1e-6)
-        volume_a = float(np.prod(extent_a))
-        for second in range(first + 1, count):
-            lower_b, upper_b = bounds[second]
-            extent_b = np.maximum(upper_b - lower_b, 1e-6)
-            volume_b = float(np.prod(extent_b))
-            intersection = np.maximum(
-                np.minimum(upper_a, upper_b) - np.maximum(lower_a, lower_b), 0.0
-            )
-            overlap = float(np.prod(intersection)) / min(volume_a, volume_b)
-            if overlap >= 0.8:
-                union(first, second)
-    groups = {}
-    for index in range(count):
-        groups.setdefault(root(index), []).append(index)
-    return list(groups.values())
-
-
-def _combine_compact_instances(instances, members, up_axis):
-    """Combine one duplicate group while retaining all evidence and earliest timing."""
-    selected = [instances[index] for index in members]
-    points = np.concatenate([instance["pts"] for instance in selected], axis=0)
-    best = max((instance["best_pts"] for instance in selected), key=len)
-    confidence = [instance.get("conf") for instance in selected]
-    confidence = (
-        np.concatenate(confidence, axis=0)
-        if all(value is not None for value in confidence)
-        else None
-    )
-    centroid, size, dimensions = _canonical_robust_centroid_extent(points, up_axis)
-    frames = set().union(*(set(instance.get("frames", ())) for instance in selected))
-    return {
-        "centroid": centroid,
-        "size": size,
-        "dims": dimensions,
-        "first_time": min(instance["first_time"] for instance in selected),
-        "pts": points,
-        "conf": confidence,
-        "best_pts": best,
-        "observations": [
-            observation
-            for instance in selected
-            for observation in instance.get("observations", [instance["pts"]])
-        ],
-        "frames": frames,
-        "n": sum(instance.get("n", len(instance["pts"])) for instance in selected),
-        "nframes": len(frames),
-        "oids": [oid for instance in selected for oid in instance.get("oids", [])],
-    }
-
-
-def _compact_instance_evidence(instance):
-    """Rank one physical-instance hypothesis by persistence and geometric support."""
-    observations = instance.get("observations", [instance["pts"]])
-    observed_points = np.array([len(observation) for observation in observations])
-    return (
-        instance.get("nframes", len(instance.get("frames", ()))),
-        len(observations),
-        float(np.median(observed_points)) if len(observed_points) else 0.0,
-        instance.get("n", len(instance["pts"])),
-    )
-
-
-def _consolidate_compact_instances(instances, stats, up_axis):
-    """Suppress duplicate tracks and retain the strongest co-visible instance set."""
-    consolidated = {}
-    for class_name, items in instances.items():
-        combined = [
-            _combine_compact_instances(items, members, up_axis)
-            for members in _compact_duplicate_groups(items)
-        ]
-        peak = int(stats.get(class_name, {}).get("peak", 0))
-        limit = min(len(combined), max(peak, 1))
-        ranked = sorted(combined, key=_compact_instance_evidence, reverse=True)
-        retained = ranked[:limit]
-        for fragment in ranked[limit:]:
-            nearest = min(
-                retained,
-                key=lambda instance: np.linalg.norm(
-                    instance["centroid"] - fragment["centroid"]
-                ),
-            )
-            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
-        consolidated[class_name] = retained
-    return consolidated
-
-
-def _compact_instances(scene, up_axis):
-    """Return consolidated physical instances for raw or canonical adapter geometry."""
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        instances, stats = build_instances(
-            raw_inputs["per"],
-            raw_inputs["depth"],
-            raw_inputs["intr"],
-            raw_inputs["c2w"],
-            raw_inputs.get("conf"),
-            raw_inputs["ftimes"],
-            up_axis=up_axis,
-        )
-    else:
-        instances = {}
-        stats = {
-            class_name: dict(values) for class_name, values in scene["stats"].items()
-        }
-        for class_name, items in scene["instances"].items():
-            measured = []
-            for item in items:
-                points = _canonical_clean(item)
-                if not len(points):
-                    points = item["pts"]
-                centroid, size, dimensions = _canonical_robust_centroid_extent(
-                    points, up_axis
-                )
-                record = dict(item)
-                record.update({"centroid": centroid, "size": size, "dims": dimensions})
-                measured.append(record)
-            instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
-    for class_name, items in instances.items():
-        stats.setdefault(class_name, {})
-        stats[class_name]["merged"] = len(items)
-    return instances, stats
-
-
-def instance_source_track_ids(scene):
-    """Return {emitted_class_name: [oids_for_instance_1, oids_for_instance_2, ...]},
-    one ordered list of raw SAM3 masklet ids per FINAL consolidated instance -- in
-    EXACTLY the rank order build_compact_spatial_code() emits instances in (same
-    (n, nframes)-descending sort, same class-name aliasing), so index i here IS the
-    "<class> {i+1}" instance id the strong correspondence overlay stamps. A raw-only
-    lookup: reruns nothing but the consolidation build_compact_spatial_code() already
-    does, just exposing the "oids" field that pipeline discards before emission (the
-    on-disk schema never carries SAM3 ids -- this function is the only place that does).
-    """
-    alias = {"coat hanger": "coat rack"}
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is None:
-        raise ValueError(
-            "instance_source_track_ids needs raw depth/intr/c2w inputs; this geometry "
-            "cache carries only canonical points (no SAM3 track ids to recover)"
-        )
-    up_vec, up_ax = room_gravity(
-        raw_inputs["depth"],
-        raw_inputs["intr"],
-        raw_inputs["c2w"],
-        raw_inputs.get("conf"),
-    )
-    instances, _stats = _compact_instances(scene, up_ax)
-    out = {}
-    for class_name, items in instances.items():
-        emitted_name = alias.get(class_name, class_name)
-        ranked = sorted(
-            items,
-            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
-            reverse=True,
-        )
-        out.setdefault(emitted_name, []).extend(item.get("oids", []) for item in ranked)
-    return out
-
-
-def build_compact_spatial_code(scene):
-    """Build reusable OBB, visibility-time, and floor-boundary primitives."""
-    alias = {"coat hanger": "coat rack"}
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        up_vec, up_ax = room_gravity(
-            raw_inputs["depth"],
-            raw_inputs["intr"],
-            raw_inputs["c2w"],
-            raw_inputs.get("conf"),
-        )
-        u, v, g = _floor_basis(up_vec)
-    else:
-        up_vec, up_ax = _canonical_room_gravity(
-            scene["scene_pts"], scene.get("cameras")
-        )
-        u, v, g = _canonical_floor_basis(up_vec)
-    instances, stats = _compact_instances(scene, up_ax)
-    all_points = np.concatenate(
-        [item["pts"] for values in instances.values() for item in values], axis=0
-    )
-    floor_level = _floor_level(all_points, g)
-    objects = {}
-    for class_name, items in instances.items():
-        emitted_name = alias.get(class_name, class_name)
-        ranked = sorted(
-            items,
-            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
-            reverse=True,
-        )
-        count = int(stats.get(class_name, {}).get("peak", 0))
-        ranked = ranked[: max(count, 1)]
-        objects.setdefault(emitted_name, []).extend(
-            {
-                "3D oriented bounding box": _compact_oriented_box(
-                    item, u, v, g, floor_level
-                ),
-                "first visible time": round(float(item["first_time"]), 2),
-            }
-            for item in ranked
-        )
-    code = {
-        "objects": objects,
-        "room": {
-            "floor boundary polygons": _compact_floor_boundary_polygons(
-                _compact_scene_points(scene), u, v
-            )
-        },
-    }
-    return code, instances, stats, up_ax, up_vec, None
-
-
-# ==========================================================================================
-# EXPLICIT SPATIAL CODE -- a strict derivation of the compact schema above. Every object
-# position/dimension/count/appearance-order value is read directly off compact's own oriented
-# boxes and "first visible time" (a direct subset, not independently recomputed); the distance
-# table is the one thing compact never stores, so it is computed here purely from compact's own
-# 3D oriented boxes -- exact surface-to-surface separation via bounded least squares (same
-# convex, closed-form-adjacent optimization symbolic/adapters.py's solver-side derivation
-# already used for compact input, now the ACTUAL on-disk construction for explicit too, so the
-# two schemas can never independently disagree about the same scene's geometry).
-# ==========================================================================================
-
-
-EXPLICIT_SPATIAL_CODE_SCHEMA = {
-    "objects": {
-        "<object class>": {
-            "count": {
-                "unit": None,
-                "description": (
-                    "number of instances of this class in the compact spatial code "
-                    "(that schema's per-class oriented-box list length)"
-                ),
-            },
-            "instances": [
-                {
-                    "position": {
-                        "x coordinate": {
-                            "unit": "meters",
-                            "description": (
-                                "x coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                        "y coordinate": {
-                            "unit": "meters",
-                            "description": (
-                                "y coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                        "height above floor": {
-                            "unit": "meters",
-                            "description": (
-                                "height coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                    },
-                    "longest dimension": {
-                        "unit": "meters",
-                        "description": (
-                            "longest of this instance's compact 3D oriented bounding box "
-                            "dimensions"
-                        ),
-                    },
-                }
-            ],
-        }
-    },
-    "room": {
-        "floor area": {
-            "unit": "square meters",
-            "description": (
-                "shoelace area of the compact spatial code's floor boundary polygons, "
-                "with every interior hole subtracted"
-            ),
-        }
-    },
-    "closest classes distance meters from": {
-        "<object class>": {
-            "<other object class>": {
-                "distance": {
-                    "unit": "meters",
-                    "description": (
-                        "estimated distance in meters between an object of this class "
-                        "and an object of the other class"
-                    ),
-                },
-                "closeness rank": {
-                    "unit": None,
-                    "description": (
-                        "1 = the nearest other class to this one, 2 = second-nearest, "
-                        "and so on; ranked by nearest-instance proximity, so use the "
-                        "rank (not the distance values) to compare which class is "
-                        "closest"
-                    ),
-                },
-            }
-        }
-    },
-    "appearance order": {
-        "unit": None,
-        "description": (
-            "class names ordered by earliest compact 'first visible time' across all of "
-            "that class's instances"
-        ),
-    },
-}
-
-
-def _compact_box_distance(box_a, box_b):
-    """Return the true minimum Euclidean separation of two compact 3D oriented boxes.
-
-    Verbatim derivation from symbolic/adapters.py's oriented_box_distance(): the six box
-    coefficients form one convex bounded least-squares problem, solved exactly by BVLS -- no
-    center, corner, or longest-dimension shortcut, so touching/intersecting boxes return zero.
-
-    Orientation vectors are renormalized to unit length before use, exactly like
-    symbolic/adapters.py's _oriented_box() -- compact's on-disk vectors are rounded to 2
-    decimals, so they are no longer *exactly* unit length, and the matrix below implicitly
-    assumes they are (each column is dimension/2 along that axis). Skipping this step is a
-    real source of error, not just a rounding artifact: it measurably shifted computed
-    distances in testing (up to ~0.01 m on real scenes), and would make explicit silently
-    disagree with what the solver derives from the identical compact box at read time.
-    """
-    from scipy.optimize import lsq_linear
-
-    center_a = np.asarray(
-        box_a["3D oriented bounding box center coordinates"], np.float64
-    )
-    dimensions_a = np.asarray(box_a["3D oriented bounding box dimensions"], np.float64)
-    orientation_a = np.asarray(
-        box_a["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation_a = orientation_a / np.linalg.norm(orientation_a, axis=1, keepdims=True)
-    center_b = np.asarray(
-        box_b["3D oriented bounding box center coordinates"], np.float64
-    )
-    dimensions_b = np.asarray(box_b["3D oriented bounding box dimensions"], np.float64)
-    orientation_b = np.asarray(
-        box_b["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation_b = orientation_b / np.linalg.norm(orientation_b, axis=1, keepdims=True)
-    matrix = np.column_stack(
-        [
-            *(dimensions_a[index] * orientation_a[index] / 2 for index in range(3)),
-            *(-dimensions_b[index] * orientation_b[index] / 2 for index in range(3)),
-        ]
-    )
-    result = lsq_linear(
-        matrix,
-        center_b - center_a,
-        bounds=(-1, 1),
-        method="bvls",
-        lsq_solver="exact",
-        tol=1e-12,
-        max_iter=200,
-    )
-    if not result.success:
-        raise RuntimeError(
-            f"oriented-box distance optimization failed: {result.message}"
-        )
-    distance = float(np.linalg.norm(matrix @ result.x + center_a - center_b))
-    return 0.0 if distance < 1e-10 else distance
-
-
-def _compact_class_distance(instances_a, instances_b):
-    """Return the minimum compact oriented-box distance across every cross-class instance pair."""
-    return min(
-        _compact_box_distance(
-            a["3D oriented bounding box"], b["3D oriented bounding box"]
-        )
-        for a in instances_a
-        for b in instances_b
-    )
-
-
-def _primary_instance_distance_floor(instances_a, instances_b):
-    """A sphere-approximation floor on the two classes' PRIMARY (instance[0]) distance:
-    3D center-to-center distance minus each primary box's longest dimension / 2, floored
-    at 0. Mirrors symbolic/solver.py's _primary_instance_distance_estimate exactly (the
-    same correction, applied at ENCODING time so the table value a reader looks up
-    already carries it -- see _corrected_class_distance below)."""
-    box_a = instances_a[0]["3D oriented bounding box"]
-    box_b = instances_b[0]["3D oriented bounding box"]
-    center_a = box_a["3D oriented bounding box center coordinates"]
-    center_b = box_b["3D oriented bounding box center coordinates"]
-    center_distance = (
-        sum((float(a) - float(b)) ** 2 for a, b in zip(center_a, center_b)) ** 0.5
-    )
-    radius_a = max(box_a["3D oriented bounding box dimensions"]) / 2
-    radius_b = max(box_b["3D oriented bounding box dimensions"]) / 2
-    return max(0.0, center_distance - (radius_a + radius_b))
-
-
-def _corrected_class_distance(instances_a, instances_b):
-    """max(min-across-pairs surface distance, primary-instance sphere floor) -- the
-    combination symbolic/solver.py applies at ANSWER time for ABSOLUTE-distance
-    questions. TRIED AND REVERTED as the table's stored value (2026-07-25, see
-    preregistration.md): baking it in re-derived the closeness RANKS from
-    corrected distances, and closest-of-class ranking is exactly where the raw
-    min-across-instances is the semantically correct quantity -- solver relative-
-    distance accuracy fell 59.2 -> 47.5 on real perceived codes and the VLM pilot
-    dropped in the same direction.
-
-    REINSTATED (2026-07-25, second amendment, see preregistration.md) as the
-    table's PRINTED distance only, with the fix the first attempt lacked: closeness
-    ranks stay computed from the raw min-across-instances distance (the correct
-    closest-of-class quantity), and the solver's relative-distance answer reads the
-    rank field rather than comparing printed values. The printed value IS the solver's
-    absolute-distance answer, making abs-distance a pure lookup for any reader."""
-    return max(
-        _compact_class_distance(instances_a, instances_b),
-        _primary_instance_distance_floor(instances_a, instances_b),
-    )
-
-
-def _compact_polygon_area(coordinates):
-    """Return the unsigned shoelace area of one ordered compact floor-boundary polygon."""
-    if len(coordinates) < 3:
-        return 0.0
-    return abs(
-        sum(
-            coordinates[index][0] * coordinates[(index + 1) % len(coordinates)][1]
-            - coordinates[(index + 1) % len(coordinates)][0] * coordinates[index][1]
-            for index in range(len(coordinates))
-        )
-        / 2
-    )
-
-
-def _compact_room_floor_area(polygons):
-    """Sum outer areas and subtract every interior hole across compact's floor regions."""
-    area = 0.0
-    for polygon in polygons:
-        area += _compact_polygon_area(polygon.get("outer boundary coordinates", []))
-        area -= sum(
-            _compact_polygon_area(hole)
-            for hole in polygon.get("interior hole boundary coordinates", [])
-        )
-    return max(0.0, area)
-
-
-def _compact_box_axis_bounds(box):
-    center = np.asarray(box["3D oriented bounding box center coordinates"], np.float64)
-    dimensions = np.asarray(box["3D oriented bounding box dimensions"], np.float64)
-    orientation = np.asarray(
-        box["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation = orientation / np.linalg.norm(orientation, axis=1, keepdims=True)
-    offsets = []
-    for sx in (-1.0, 1.0):
-        for sy in (-1.0, 1.0):
-            for sz in (-1.0, 1.0):
-                offsets.append(
-                    sx * dimensions[0] * orientation[0] / 2
-                    + sy * dimensions[1] * orientation[1] / 2
-                    + sz * dimensions[2] * orientation[2] / 2
-                )
-    corners = center + np.asarray(offsets)
-    return [
-        [
-            round(float(corners[:, axis].min()), 2),
-            round(float(corners[:, axis].max()), 2),
-        ]
-        for axis in range(3)
-    ]
-
-
-def _compact_outline_for_v2(compact_code):
-    polygons = compact_code.get("room", {}).get("floor boundary polygons", [])
-    if not polygons:
-        return []
-    outline = []
-    for x, y in polygons[0].get("outer boundary coordinates", []):
-        outline.append(
-            {"floor_x_meters": round(float(x), 1), "floor_y_meters": round(float(y), 1)}
-        )
-    return outline
-
-
-def _explicit_from_compact(compact_code):
-    """Derive a V2 explicit spatial code from an already-built compact spatial code.
-
-    This is used for canonical adapter geometry and ground truth. It mirrors the V2 envelope
-    used by the raw encoder path: no embedded legend, numeric closest-class table, V2 room
-    keys, and compact "appearance order".
-    """
-    compact_objects = compact_code["objects"]
-
-    objects = {}
-    first_visible = {}
-    for class_name, items in compact_objects.items():
-        rendered = []
-        for item in items:
-            box = item["3D oriented bounding box"]
-            center = box["3D oriented bounding box center coordinates"]
-            dimensions = box["3D oriented bounding box dimensions"]
-            bounds = _compact_box_axis_bounds(box)
-            rendered.append(
-                {
-                    "position": {
-                        "floor_x_meters": round(float(center[0]), 2),
-                        "floor_y_meters": round(float(center[1]), 2),
-                        "height_above_floor_meters": round(float(center[2]), 2),
-                    },
-                    "longest_dimension_meters": round(float(max(dimensions)), 2),
-                    "bounding_box": {
-                        "floor_x_meters": bounds[0],
-                        "floor_y_meters": bounds[1],
-                        "height_above_floor_meters": bounds[2],
-                    },
-                    "dimensions_meters": [
-                        round(float(value), 2) for value in dimensions
-                    ],
-                }
-            )
-            time = item["first visible time"]
-            if time is not None:
-                first_visible[class_name] = min(
-                    first_visible.get(class_name, float("inf")), float(time)
-                )
-        objects[class_name] = {"count": len(items), "instances": rendered}
-
-    classes = [name for name, items in compact_objects.items() if items]
-    raw_distances = {class_name: {} for class_name in classes}
-    printed_distances = {class_name: {} for class_name in classes}
-    for index, class_name in enumerate(classes):
-        for other in classes[index + 1 :]:
-            raw = _compact_class_distance(
-                compact_objects[class_name], compact_objects[other]
-            )
-            printed = _corrected_class_distance(
-                compact_objects[class_name], compact_objects[other]
-            )
-            raw_distances[class_name][other] = raw
-            raw_distances[other][class_name] = raw
-            printed_distances[class_name][other] = printed
-            printed_distances[other][class_name] = printed
-    closest = {}
-    for class_name, distances in raw_distances.items():
-        ranked = sorted(distances.items(), key=lambda item: (item[1], item[0]))
-        closest[class_name] = {
-            other: {
-                "closeness_rank": rank + 1,
-                "distance_meters": round(printed_distances[class_name][other], 2),
-            }
-            for rank, (other, _raw) in enumerate(ranked)
-        }
-
-    floor_area = round(
-        _compact_room_floor_area(
-            compact_code["room"].get("floor boundary polygons", [])
-        ),
-        1,
-    )
-
-    return {
-        "objects": objects,
-        "room": {
-            "outline": _compact_outline_for_v2(compact_code),
-            "floor_area_square_meters": floor_area,
-        },
-        "closest_classes_from": closest,
-        "appearance order": sorted(
-            classes, key=lambda name: first_visible.get(name, float("inf"))
-        ),
-    }, floor_area
-
-
-def _build_reference_v2_spatial_code(raw_inputs):
-    """Build the raw encoder spatial code exactly like the reference V2 branch."""
-    alias = {"coat hanger": "coat rack"}
-    per = {
-        alias.get(class_name, class_name): frames
-        for class_name, frames in raw_inputs["per"].items()
-    }
-    depth = raw_inputs["depth"]
-    intr = raw_inputs["intr"]
-    c2w = raw_inputs["c2w"]
-    conf = raw_inputs.get("conf")
-    frame_times = raw_inputs["ftimes"]
-
-    up_vec, up_axis = room_gravity(depth, intr, c2w, conf)
-    instances, stats = build_instances(
-        per, depth, intr, c2w, conf, frame_times, up_axis=up_axis
-    )
-    u, v, g = _floor_basis(up_vec)
-    all_points = np.concatenate(
-        [item["pts"] for values in instances.values() for item in values], axis=0
-    )
-    floor_level = float(np.percentile(all_points @ g, 2))
-    floor_area = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
-    code = _reference_to_spatial_code(
-        instances, stats, floor_area, up_axis, up_vec, floor_level
-    )
-    classes = list(instances.keys())
-    class_first = {
-        class_name: min(item["first_time"] for item in values)
-        for class_name, values in instances.items()
-    }
-
-    for class_name in classes:
-        ranked = sorted(
-            instances[class_name],
-            key=lambda item: (item["n"], item.get("nframes", 0)),
-            reverse=True,
-        )
-        for record, item in zip(code["objects"][class_name]["instances"], ranked):
-            record["seen_in_video_frames"] = int(
-                item.get("nframes", len(item.get("frames", ())))
-            )
-
-    closest = {}
-    for class_name in classes:
-        distances = sorted(
-            (
-                round(
-                    answer_closest_distance(instances[class_name], instances[other]), 2
-                ),
-                other,
-            )
-            for other in classes
-            if other != class_name
-        )
-        closest[class_name] = {
-            other: {"closeness_rank": rank + 1, "distance_meters": distance}
-            for rank, (distance, other) in enumerate(distances)
-        }
-    code["closest_classes_from"] = closest
-
-    waypoints = []
-    next_time = 0.0
-    for index, time_seconds in enumerate(np.asarray(frame_times, np.float64)):
-        if time_seconds + 1e-9 < next_time:
-            continue
-        next_time = float(time_seconds) + 5.0
-        position = c2w[index][:3, 3]
-        forward = c2w[index][:3, 2]
-        waypoints.append(
-            {
-                "time_seconds": round(float(time_seconds), 1),
-                "floor_x_meters": round(float(position @ u), 2),
-                "floor_y_meters": round(float(position @ v), 2),
-                "heading_degrees": round(
-                    float(np.degrees(np.arctan2(forward @ v, forward @ u)))
-                ),
-            }
-        )
-    code["camera_trajectory"] = {
-        "sample_interval_seconds": 5,
-        "waypoints": waypoints,
-    }
-    code["room"] = {
-        "outline": _room_outline(depth, intr, c2w, conf, u, v),
-        "floor_area_square_meters": code["room"]["floor_area_square_meters"],
-    }
-    code["appearance order"] = [
-        class_name
-        for class_name, _time in sorted(class_first.items(), key=lambda item: item[1])
-    ]
-    return code, instances, stats, up_axis, up_vec, floor_area
-
-
-def build_explicit_spatial_code(scene):
-    """Build the selected explicit code.
-
-    Raw encoder inputs follow the original geometric V2 spatial-code construction. Canonical
-    geometry keeps the compact-derived schema used by ground-truth and non-raw adapters.
-    """
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        return _build_reference_v2_spatial_code(raw_inputs)
-
-    compact_code, instances, stats, up_ax, up_vec, _ = build_compact_spatial_code(scene)
-    code, floor_area = _explicit_from_compact(compact_code)
-    return code, instances, stats, up_ax, up_vec, floor_area
-
-
-# ==========================================================================================
-# MODEL-AGNOSTIC ENTRY POINT
-# ==========================================================================================
-
-
-def build_spatial_code(scene, spatial_code_format="explicit"):
-    """Build one selected spatial-code schema from canonical scene geometry.
-
-    Compact is built directly from raw depth/pose/mask bundles or canonical world-space
-    geometry (build_compact_spatial_code() handles that duality). Explicit is always a
-    derivation of compact (build_explicit_spatial_code() calls build_compact_spatial_code()
-    first), so there is no separate raw/canonical branch for explicit any more.
-    """
-    if spatial_code_format == "compact":
-        return build_compact_spatial_code(scene)
-    if spatial_code_format != "explicit":
-        raise ValueError(f"unknown spatial-code format {spatial_code_format!r}")
-    return build_explicit_spatial_code(scene)

encoder/__init__.py

@@ -1 +0,0 @@
-"""Spatial-code encoder package."""

encoder/adapters.py

@@ -1,586 +0,0 @@
-"""Model-output adapters -- the ONLY file that knows any model's native output shape.
-
-Every adapter returns THE canonical geometry dict below. geometric.py sees only this dict:
-
-    instances: class -> list of already-reconstructed 3D instance dicts
-    stats:     class -> raw/merged/peak counts
-    scene_pts: full-scene world points used by gravity/floor-area math
-    cameras:   world-space camera positions (only to orient gravity upward)
-    raw_inputs: optional raw depth/pose/mask bundle for exact reference-math execution
-
-Adapters may decode depth, masks, queries, meshes, voxels, Gaussians, or anything else. None
-of those representations cross this file boundary.
-"""
-
-from __future__ import annotations
-
-import gzip
-import os
-import pickle
-import sys
-
-import numpy as np
-
-CACHE_ROOT = os.environ.get("VSI_CACHE_ROOT", "/root/data/caches")
-FPS = float(os.environ.get("VSI_FPS", "6"))
-MODELS_ROOT = os.environ.get("VSI_MODELS_ROOT", "/root/models")
-DA3_ROOT = os.environ.get("VSI_DA3_ROOT", os.path.join(MODELS_ROOT, "depth-anything-3"))
-SEGVGGT_ROOT = os.environ.get("VSI_SEGVGGT_ROOT", os.path.join(MODELS_ROOT, "SegVGGT"))
-
-
-RAW_CACHE_ROOT = CACHE_ROOT
-SPATIAL_CODE_FORMATS = ("compact", "explicit")
-
-
-def _raw_cache_root(root=None):
-    """Resolve the shared inference-output root without importing encoder config."""
-    return root or os.environ.get("VSI_CACHE_ROOT", RAW_CACHE_ROOT)
-
-
-def validate_spatial_code_format(spatial_code_format):
-    """Validate one output format at the model-agnostic geometry boundary."""
-    if spatial_code_format not in SPATIAL_CODE_FORMATS:
-        raise ValueError(
-            f"unknown spatial-code format {spatial_code_format!r}; "
-            f"expected {SPATIAL_CODE_FORMATS}"
-        )
-    return spatial_code_format
-
-
-# ==========================================================================================
-# CANONICAL SHAPE -- validation only. Plain dicts on purpose: no schema/contract class layer.
-# ==========================================================================================
-
-
-def _pts(x, where):
-    p = np.asarray(x, np.float32)
-    if p.ndim != 2 or p.shape[1] != 3:
-        raise ValueError(f"{where} must be [N,3], got {p.shape}")
-    return p[np.isfinite(p).all(1)]
-
-
-class EmptySceneError(ValueError):
-    """Raised when a valid adapter result contains no spatial instances."""
-
-
-def validate(scene):
-    """Coerces one adapter result to THE canonical shape and fails loudly on drift."""
-    if not isinstance(scene, dict):
-        raise TypeError("adapter result must be a dict")
-    if not scene.get("instances"):
-        raise EmptySceneError("adapter produced no instances")
-    for cls, insts in scene["instances"].items():
-        for i in insts:
-            i["pts"] = _pts(i["pts"], f"{cls}.pts")
-            i["best_pts"] = _pts(i.get("best_pts", i["pts"]), f"{cls}.best_pts")
-            i["n"] = int(i.get("n", len(i["pts"])))
-            i["frames"] = set(i.get("frames", ()))
-            i["nframes"] = int(i.get("nframes", len(i["frames"])))
-            i["first_time"] = float(i.get("first_time", 0.0))
-            if i.get("conf") is not None:
-                i["conf"] = np.asarray(i["conf"], np.float32).reshape(-1)
-    scene["scene_pts"] = _pts(scene["scene_pts"], "scene_pts")
-    if scene.get("cameras") is not None:
-        scene["cameras"] = _pts(scene["cameras"], "cameras")
-    return scene
-
-
-# ==========================================================================================
-# DA3 + SAM3 -- compatibility adapter for the existing cache. All depth/mask projection lives
-# HERE, not geometric.py. The geometric cleanup/measurement math is unchanged downstream.
-# ==========================================================================================
-
-
-def _load_masks(path):
-    candidates = [path]
-    if os.path.isdir(path):
-        candidates = [
-            os.path.join(path, n)
-            for n in ("sam3.pkl.gz", "sam3_full.pkl.gz", "sam3.pkl")
-        ]
-    for path in candidates:
-        if not os.path.exists(path):
-            continue
-        op = gzip.open if path.endswith(".gz") else open
-        with op(path, "rb") as f:
-            packed = pickle.load(f)
-        out = {}
-        for cls, frames in packed.items():
-            out[cls] = {}
-            for fi, objects in frames.items():
-                out[cls][int(fi)] = {}
-                for oid, value in objects.items():
-                    if isinstance(value, tuple) and len(value) == 2:
-                        bits, shape = value
-                        m = (
-                            np.unpackbits(bits)[: int(np.prod(shape))]
-                            .reshape(shape)
-                            .astype(bool)
-                        )
-                    else:
-                        m = np.asarray(value, bool)
-                    out[cls][int(fi)][int(oid)] = m
-        return out
-    raise FileNotFoundError(f"no SAM3 cache found at {path}")
-
-
-def _sam3_response_masks(response, frame_index, allow_empty):
-    """Normalize one tracked or independent SAM3 response to object-id masks."""
-    if not isinstance(response, dict):
-        raise ValueError(
-            f"invalid SAM3 response at frame {frame_index}; expected a dict"
-        )
-    outputs = (
-        response.get("outputs")
-        if isinstance(response.get("outputs"), dict)
-        else response
-    )
-    masks = outputs.get("masks")
-    if masks is None:
-        masks = outputs.get("out_binary_masks")
-    if masks is None:
-        if allow_empty and not outputs:
-            return {}
-        raise ValueError(f"SAM3 response at frame {frame_index} has no masks")
-    masks = (
-        masks.detach().cpu().numpy() if hasattr(masks, "detach") else np.asarray(masks)
-    )
-    if masks.ndim == 2:
-        masks = masks[None]
-    if masks.ndim == 4 and masks.shape[1] == 1:
-        masks = masks[:, 0]
-    if masks.ndim != 3:
-        raise ValueError(
-            f"SAM3 masks at frame {frame_index} must be [N,H,W], got {masks.shape}"
-        )
-    object_ids = outputs.get("out_obj_ids")
-    if object_ids is None:
-        object_ids = range(len(masks))
-    elif hasattr(object_ids, "detach"):
-        object_ids = object_ids.detach().cpu().numpy()
-    return {
-        int(object_id): mask.astype(bool) for object_id, mask in zip(object_ids, masks)
-    }
-
-
-def _load_native_sam3(path):
-    """Decode tracked or independent native SAM3 frame responses."""
-    try:
-        import torch
-    except ImportError as exc:
-        raise RuntimeError("PyTorch is required to read a raw SAM3 .pt cache") from exc
-    responses = torch.load(path, map_location="cpu", weights_only=False)
-    if isinstance(responses, dict):
-        decoded = {}
-        for class_name, class_responses in responses.items():
-            if isinstance(class_responses, dict) and "stream" in class_responses:
-                # Lossless tracking caches retain complete request responses and
-                # streamed envelopes. Only the stream is needed for geometry.
-                stream = class_responses["stream"]
-                if not isinstance(stream, list):
-                    raise ValueError(
-                        f"invalid SAM3 stream for {class_name!r}; expected a list"
-                    )
-                decoded[str(class_name)] = {
-                    int(response["frame_index"]): _sam3_response_masks(
-                        response, int(response["frame_index"]), True
-                    )
-                    for response in stream
-                    if isinstance(response, dict)
-                    and response.get("frame_index") is not None
-                }
-                continue
-            if not isinstance(class_responses, list):
-                raise ValueError(
-                    f"invalid SAM3 responses for {class_name!r}; expected a list"
-                )
-            decoded[str(class_name)] = {
-                frame_index: _sam3_response_masks(response, frame_index, True)
-                for frame_index, response in enumerate(class_responses)
-            }
-        return decoded
-    if not isinstance(responses, list):
-        raise ValueError(f"invalid SAM3 raw cache {path}; expected a list or dict")
-    class_name = os.environ.get("VSI_SAM3_PROMPT", "object")
-    return {
-        class_name: {
-            frame_index: _sam3_response_masks(response, frame_index, False)
-            for frame_index, response in enumerate(responses)
-        }
-    }
-
-
-def _load_native_da3(path):
-    """Decode DA3's exact pickled Prediction object into projection inputs."""
-    model_root = str(DA3_ROOT)
-    source_root = os.path.join(model_root, "src")
-    if source_root not in sys.path:
-        sys.path.insert(0, source_root)
-    with open(path, "rb") as stream:
-        prediction = pickle.load(stream)
-
-    def field(name, required=True):
-        value = getattr(prediction, name, None)
-        if value is None and isinstance(prediction, dict):
-            value = prediction.get(name)
-        if required and value is None:
-            raise ValueError(f"DA3 Prediction in {path} has no {name}")
-        return value
-
-    depth = np.asarray(field("depth"), np.float32)
-    intr = np.asarray(field("intrinsics"), np.float32)
-    extr = np.asarray(field("extrinsics"), np.float32)
-    if extr.shape[-2:] == (3, 4):
-        homogeneous = np.broadcast_to(
-            np.eye(4, dtype=np.float32), extr.shape[:-2] + (4, 4)
-        ).copy()
-        homogeneous[..., :3, :] = extr
-        extr = homogeneous
-    if extr.shape[-2:] != (4, 4):
-        raise ValueError(f"DA3 extrinsics must end in [3,4] or [4,4], got {extr.shape}")
-    c2w = np.linalg.inv(extr).astype(np.float32)
-    conf_value = field("conf", required=False)
-    conf = np.asarray(conf_value, np.float32) if conf_value is not None else None
-    return depth, intr, c2w, conf
-
-
-def _resize_mask_nearest(mask, shape):
-    """Resize one boolean mask to a depth-map shape with nearest sampling."""
-    mask = np.asarray(mask, bool)
-    if mask.ndim != 2:
-        raise ValueError(f"mask must be two-dimensional, got {mask.shape}")
-    if mask.shape == tuple(shape):
-        return mask
-    source_height, source_width = mask.shape
-    target_height, target_width = shape
-    rows = np.minimum(
-        np.arange(target_height) * source_height // target_height,
-        source_height - 1,
-    )
-    columns = np.minimum(
-        np.arange(target_width) * source_width // target_width,
-        source_width - 1,
-    )
-    return mask[np.ix_(rows, columns)]
-
-
-def _backproject(depth, intrinsics, c2w, mask, conf=None):
-    mask = _resize_mask_nearest(mask, depth.shape)
-    ys, xs = np.nonzero(mask)
-    z = depth[ys, xs]
-    ok = np.isfinite(z) & (z > 0)
-    ys, xs, z = ys[ok], xs[ok], z[ok]
-    if not len(z):
-        return np.zeros((0, 3), np.float32), None
-    camera_points = np.stack(
-        [
-            (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
-            (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
-            z,
-        ],
-        1,
-    )
-    world_points = (c2w[:3, :3] @ camera_points.T).T + c2w[:3, 3]
-    cf = conf[ys, xs].astype(np.float32) if conf is not None else None
-    return world_points.astype(np.float32), cf
-
-
-def _fusion_cache_paths(root, da3_path, sam3_path, scene):
-    if scene:
-        root = _raw_cache_root(root)
-        da3_path = da3_path or os.path.join(root, "depth-anything-3", f"{scene}.pkl")
-        sam3_path = sam3_path or os.path.join(root, "sam3", f"{scene}.pt")
-    if da3_path is None:
-        da3_path = os.path.join(root, "da3.npz") if root else None
-    if sam3_path is None:
-        sam3_path = root
-    if not da3_path:
-        raise ValueError("da3_path is required")
-    return da3_path, sam3_path
-
-
-def _load_fusion_inputs(da3_path, sam3_path):
-    if str(da3_path).endswith(".pkl"):
-        depth, intr, c2w, conf = _load_native_da3(da3_path)
-        ft = np.arange(len(depth), dtype=np.float32) / FPS
-    else:
-        d = np.load(da3_path)
-        depth, intr, c2w = d["depth"], d["intr"], d["c2w"]
-        conf = d["conf"] if "conf" in d and d["conf"].size else None
-        ft = (
-            d["frame_times"]
-            if "frame_times" in d
-            else np.arange(len(depth), dtype=np.float32)
-        )
-    per = (
-        _load_native_sam3(sam3_path)
-        if str(sam3_path).endswith(".pt")
-        else _load_masks(sam3_path)
-    )
-    return depth, intr, c2w, conf, ft, per
-
-
-def _fuse_mask_instances(per, depth, intr, c2w, conf, frame_times):
-    instances, stats = {}, {}
-    for cls, frames in per.items():
-        by_id = {}
-        peak = max((len(v) for v in frames.values()), default=0)
-        for fi, objects in frames.items():
-            for oid, mask in objects.items():
-                pts, cf = _backproject(
-                    depth[fi],
-                    intr[fi],
-                    c2w[fi],
-                    mask,
-                    conf[fi] if conf is not None else None,
-                )
-                if not len(pts):
-                    continue
-                r = by_id.setdefault(
-                    oid,
-                    {
-                        "chunks": [],
-                        "conf": [],
-                        "frames": set(),
-                        "first_time": float(frame_times[fi]),
-                    },
-                )
-                r["chunks"].append(pts)
-                r["frames"].add(fi)
-                if cf is not None:
-                    r["conf"].append(cf)
-        raw = []
-        for r in by_id.values():
-            pts = np.concatenate(r["chunks"], 0)
-            raw.append(
-                {
-                    "pts": pts,
-                    "best_pts": max(r["chunks"], key=len),
-                    "observations": list(r["chunks"]),
-                    "conf": np.concatenate(r["conf"], 0) if r["conf"] else None,
-                    "frames": r["frames"],
-                    "nframes": len(r["frames"]),
-                    "n": len(pts),
-                    "first_time": r["first_time"],
-                }
-            )
-        if raw:
-            instances[cls] = raw
-            stats[cls] = {"raw": len(raw), "merged": len(raw), "peak": peak}
-    return instances, stats
-
-
-def _sample_scene_points(depth, intr, c2w):
-    scene_points = []
-    for fi in range(0, len(depth), 3):
-        m = np.zeros_like(depth[fi], bool)
-        m[::8, ::8] = True
-        pts, _ = _backproject(depth[fi], intr[fi], c2w[fi], m)
-        if len(pts):
-            scene_points.append(pts)
-    return np.concatenate(scene_points, 0)
-
-
-def adapt_sam3_depth_anything_3(
-    root=None, da3_path=None, sam3_path=None, scene=None, **_
-):
-    """Fuse raw DA3 geometry and raw per-frame SAM3 masks into canonical geometry."""
-    da3_path, sam3_path = _fusion_cache_paths(root, da3_path, sam3_path, scene)
-    depth, intr, c2w, conf, frame_times, per = _load_fusion_inputs(da3_path, sam3_path)
-    instances, stats = _fuse_mask_instances(per, depth, intr, c2w, conf, frame_times)
-    return validate(
-        {
-            "instances": instances,
-            "stats": stats,
-            "scene_pts": _sample_scene_points(depth, intr, c2w),
-            "cameras": c2w[:, :3, 3],
-            "raw_inputs": {
-                "depth": depth,
-                "intr": intr,
-                "c2w": c2w,
-                "conf": conf,
-                "ftimes": frame_times,
-                "per": per,
-            },
-        }
-    )
-
-
-# ==========================================================================================
-# SegVGGT -- reads one deliberately boring NPZ export and groups already-world-space
-# points by instance mask. Model inference is intentionally outside the encoder package.
-# ==========================================================================================
-
-
-SEGVGGT_CLASSES = """wall|floor|chair|table|door|couch|cabinet|shelf|desk|office chair|bed|pillow|sink|picture|window|toilet|bookshelf|monitor|curtain|book|armchair|coffee table|box|refrigerator|lamp|kitchen cabinet|towel|clothes|tv|nightstand|counter|dresser|stool|cushion|plant|ceiling|bathtub|end table|dining table|keyboard|bag|backpack|toilet paper|printer|tv stand|whiteboard|blanket|shower curtain|trash can|closet|stairs|microwave|stove|shoe|computer tower|bottle|bin|ottoman|bench|board|washing machine|mirror|copier|basket|sofa chair|file cabinet|fan|laptop|shower|paper|person|paper towel dispenser|oven|blinds|rack|plate|blackboard|piano|suitcase|rail|radiator|recycling bin|container|wardrobe|soap dispenser|telephone""".split(
-    "|"
-)
-
-
-def _decode_segvggt_raw(path):
-    """Decode the official SegVGGT.forward tensor dictionary for this adapter."""
-    import sys
-
-    try:
-        import torch
-        import torch.nn.functional as functional
-    except ImportError as exc:
-        raise RuntimeError("PyTorch is required to read a SegVGGT .pt cache") from exc
-
-    model_root = str(SEGVGGT_ROOT)
-    if model_root not in sys.path:
-        sys.path.insert(0, model_root)
-    try:
-        from eval.instance_eval_common import predict_by_feat_instance
-        from segvggt.utils.pose_enc import pose_encoding_to_extri_intri
-    except ImportError as exc:
-        raise RuntimeError(
-            "SegVGGT is required to decode its native prediction dictionary"
-        ) from exc
-
-    raw = torch.load(path, map_location="cpu", weights_only=False)
-    required = {"world_points", "instance_maps", "instance_labels", "pose_enc"}
-    if not isinstance(raw, dict) or not required.issubset(raw):
-        missing = (
-            sorted(required - set(raw)) if isinstance(raw, dict) else sorted(required)
-        )
-        raise ValueError(f"invalid SegVGGT raw cache {path}; missing keys: {missing}")
-
-    logits = raw["instance_maps"][0]
-    query_count, frame_total, height, width = logits.shape
-    masks, label_ids, _ = predict_by_feat_instance(
-        raw["instance_labels"][0],
-        logits.reshape(query_count, -1),
-        mask_thr=float(os.environ.get("VSI_MASK_THR", "0.4")),
-        npoint_thr=1,
-    )
-    masks = masks.reshape(-1, frame_total, height, width).cpu().numpy()
-    label_ids = label_ids.cpu().numpy()
-    keep = [index for index, label in enumerate(label_ids) if int(label) >= 2]
-
-    world = raw["world_points"][0].float()
-    if tuple(world.shape[1:3]) != (height, width):
-        world = functional.interpolate(
-            world.permute(0, 3, 1, 2),
-            (height, width),
-            mode="nearest",
-        ).permute(0, 2, 3, 1)
-    world = world.cpu().numpy()
-
-    if "images" in raw:
-        image_size = raw["images"].shape[-2:]
-    elif "depth" in raw:
-        image_size = raw["depth"].shape[2:4]
-    else:
-        image_size = (height, width)
-    extrinsics, _ = pose_encoding_to_extri_intri(raw["pose_enc"].float(), image_size)
-    extrinsics = extrinsics[0].cpu().numpy()
-    rotations = extrinsics[:, :3, :3]
-    translations = extrinsics[:, :3, 3]
-    cameras = -np.einsum("sji,sj->si", rotations, translations)
-    labels = np.asarray(
-        [
-            (
-                SEGVGGT_CLASSES[int(label_ids[index])]
-                if int(label_ids[index]) < len(SEGVGGT_CLASSES)
-                else f"class {int(label_ids[index])}"
-            )
-            for index in keep
-        ],
-        dtype=object,
-    )
-    return {
-        "world_points": world,
-        "instance_masks": masks[keep].astype(bool),
-        "labels": labels,
-        "camera_positions": cameras.astype(np.float32),
-    }
-
-
-def adapt_segvggt(root=None, path=None, scene=None, **_):
-    """Translate a raw-preserving SegVGGT cache to canonical geometry."""
-    if path is None and scene:
-        root = _raw_cache_root(root)
-        path = os.path.join(root, "segvggt", f"{scene}.pt")
-    else:
-        path = path or root
-    if path is None:
-        raise ValueError("SegVGGT cache path is required")
-    if os.path.isdir(path):
-        path = os.path.join(path, f"{scene}.pt" if scene else "geometry.pt")
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"SegVGGT raw cache does not exist: {path}")
-    if str(path).endswith(".pt"):
-        d = _decode_segvggt_raw(path)
-    else:
-        d = np.load(path, allow_pickle=True)
-    world, masks = (
-        np.asarray(d["world_points"], np.float32),
-        np.asarray(d["instance_masks"], bool),
-    )
-    labels = [str(x) for x in d["labels"].tolist()]
-    ft = (
-        d["frame_times"]
-        if "frame_times" in d
-        else np.arange(world.shape[0], dtype=np.float32)
-    )
-    instances = {}
-    for cls, mask in zip(labels, masks):
-        fs = np.flatnonzero(mask.reshape(mask.shape[0], -1).any(1))
-        chunks = [world[f][mask[f]] for f in fs if mask[f].any()]
-        chunks = [p[np.isfinite(p).all(1)] for p in chunks if len(p)]
-        if not chunks:
-            continue
-        pts = np.concatenate(chunks, 0)
-        instances.setdefault(cls, []).append(
-            {
-                "pts": pts,
-                "best_pts": max(chunks, key=len),
-                "observations": list(chunks),
-                "conf": None,
-                "frames": set(map(int, fs)),
-                "nframes": len(fs),
-                "n": len(pts),
-                "first_time": float(ft[fs[0]]) if len(fs) else 0.0,
-            }
-        )
-    stats = {}
-    for cls, insts in instances.items():
-        n = {}
-        for i in insts:
-            for f in i["frames"]:
-                n[f] = n.get(f, 0) + 1
-        stats[cls] = {
-            "raw": len(insts),
-            "merged": len(insts),
-            "peak": max(n.values(), default=len(insts)),
-        }
-    return validate(
-        {
-            "instances": instances,
-            "stats": stats,
-            "scene_pts": world.reshape(-1, 3),
-            "cameras": d["camera_positions"] if "camera_positions" in d else None,
-        }
-    )
-
-
-RAW_ADAPTERS = {
-    "sam3+depth-anything-3": adapt_sam3_depth_anything_3,
-    "segvggt": adapt_segvggt,
-}
-
-
-def available_models():
-    """Return raw model formats supported by the encoder."""
-    return tuple(sorted(RAW_ADAPTERS))
-
-
-def adapt(model, **raw_cache):
-    """Dispatch one model's native cache to its isolated format adapter."""
-    adapter = RAW_ADAPTERS.get(model)
-    if adapter is None:
-        raise KeyError(
-            f"no raw encoder adapter for {model!r}; expected one of {available_models()}"
-        )
-    return validate(adapter(**raw_cache))

encoder/config.py

@@ -1,166 +0,0 @@
-"""Configuration and path helpers for the VSI spatial-code encoder."""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-MODEL = "sam3+depth-anything-3"
-FRAMES_PER_VIDEO = int(os.environ.get("VSI_FRAMES_PER_VIDEO", "32"))
-FPS = float(os.environ.get("VSI_FPS", "6"))
-
-WORKSPACE_ROOT = Path(
-    os.environ.get("VSI_WORKSPACE_ROOT", Path(__file__).resolve().parent.parent)
-).resolve()
-DATA_ROOT = Path(os.environ.get("VSI_DATA_ROOT", "/root/data"))
-VSI_ROOT = Path(os.environ.get("VSI_ROOT", DATA_ROOT / "VSI-Bench"))
-JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
-CACHE_ROOT = Path(os.environ.get("VSI_CACHE_ROOT", DATA_ROOT / "caches"))
-CODES_ROOT = Path(
-    os.environ.get("VSI_CODES", WORKSPACE_ROOT / "data" / "spatial codes")
-)
-VIDEO_DATASETS = ("scannet", "scannetpp", "arkitscenes")
-DEPTH_VARIANTS = ("relative", "metric")
-INPUT_SELECTIONS = ("uniform", "selective")
-VIDEO_INPUT_SELECTION = "video"
-VIDEO_FRAME_SELECTION = "uniform"
-VIDEO_CACHE_SEGMENT = "video"
-TRACKING_MODES = ("tracking", "no tracking")
-SPATIAL_CODE_FORMATS = ("compact", "explicit")
-
-
-def _validate_dimensions(
-    depth, input_selection, tracking, frame_count, allow_video=False
-):
-    """Validate the dimensions shared by cache and spatial-code paths."""
-    if depth not in DEPTH_VARIANTS:
-        raise ValueError(f"unknown depth variant {depth!r}; expected {DEPTH_VARIANTS}")
-    selections = INPUT_SELECTIONS + ((VIDEO_INPUT_SELECTION,) if allow_video else ())
-    if input_selection not in selections:
-        raise ValueError(
-            f"unknown input selection {input_selection!r}; expected {selections}"
-        )
-    if tracking not in TRACKING_MODES:
-        raise ValueError(
-            f"unknown tracking mode {tracking!r}; expected {TRACKING_MODES}"
-        )
-    if input_selection != VIDEO_INPUT_SELECTION and (
-        frame_count is None or frame_count < 1
-    ):
-        raise ValueError("frame count must be positive")
-
-
-def _combined_directory(
-    root, depth, input_selection, tracking, frame_count, allow_video=False
-):
-    """Build the combined hierarchy: tracking/{frames/<selection>|video}."""
-    _validate_dimensions(depth, input_selection, tracking, frame_count, allow_video)
-    directory = Path(root) / tracking
-    if input_selection == VIDEO_INPUT_SELECTION:
-        return directory / VIDEO_CACHE_SEGMENT
-    return directory / "frames" / input_selection / str(frame_count)
-
-
-def video_path(scene, dataset=None):
-    """Return the unique MP4 for ``scene`` from the VSI-Bench dataset folders."""
-    scene = str(scene)
-    datasets = (dataset,) if dataset else VIDEO_DATASETS
-    matches = []
-    for name in datasets:
-        if name not in VIDEO_DATASETS:
-            raise ValueError(
-                f"unknown VSI dataset {name!r}; expected one of {VIDEO_DATASETS}"
-            )
-        candidate = VSI_ROOT / name / f"{scene}.mp4"
-        if candidate.is_file():
-            matches.append(candidate)
-    if not matches:
-        searched = ", ".join(str(VSI_ROOT / d / f"{scene}.mp4") for d in datasets)
-        raise FileNotFoundError(
-            f"video for scene {scene!r} not found; searched: {searched}"
-        )
-    if len(matches) > 1:
-        raise RuntimeError(f"scene {scene!r} exists in multiple datasets: {matches}")
-    return str(matches[0])
-
-
-def cache_file(scene, depth, input_selection, tracking, frame_count=FRAMES_PER_VIDEO):
-    """Return one combined geometry cache isolated by every input dimension."""
-    directory = _combined_directory(
-        CACHE_ROOT / MODEL,
-        depth,
-        input_selection,
-        tracking,
-        frame_count,
-        allow_video=True,
-    )
-    return str(directory / f"{scene}.pkl.gz")
-
-
-def da3_cache_file(scene, depth, input_selection, frame_count=FRAMES_PER_VIDEO):
-    """Return one native DA3 cache path; tracking never applies to DA3."""
-    _validate_dimensions(depth, input_selection, "tracking", frame_count)
-    directory = CACHE_ROOT / "depth-anything-3" / depth / "frames" / input_selection
-    return str(directory / str(frame_count) / f"{scene}.pkl")
-
-
-def sam3_cache_file(scene, input_selection, tracking, frame_count=FRAMES_PER_VIDEO):
-    """Return one native SAM3 cache path for a specific set of input dimensions."""
-    _validate_dimensions("relative", input_selection, tracking, frame_count)
-    directory = CACHE_ROOT / "sam3" / tracking / "frames" / input_selection
-    return str(directory / str(frame_count) / f"{scene}.pt")
-
-
-def video_da3_cache_file(scene, depth="metric", input_selection=VIDEO_FRAME_SELECTION):
-    """Return the DA3 full-video cache for the encoder's video layout."""
-    _validate_dimensions(depth, input_selection, "tracking", FRAMES_PER_VIDEO)
-    directory = CACHE_ROOT / "depth-anything-3" / depth / VIDEO_CACHE_SEGMENT
-    return str(directory / f"{scene}.npz")
-
-
-def video_sam3_cache_file(
-    scene, tracking="no tracking", input_selection=VIDEO_FRAME_SELECTION
-):
-    """Return the SAM3 full-video cache for the encoder's video layout."""
-    _validate_dimensions("relative", input_selection, tracking, FRAMES_PER_VIDEO)
-    directory = CACHE_ROOT / "sam3" / tracking / VIDEO_CACHE_SEGMENT
-    return str(directory / f"{scene}.pkl.gz")
-
-
-def spatial_code_model_dir(
-    depth,
-    input_selection,
-    tracking,
-    frame_count=FRAMES_PER_VIDEO,
-    spatial_code_format="explicit",
-):
-    """Return one final spatial-code directory for a specific set of input dimensions."""
-    if spatial_code_format not in SPATIAL_CODE_FORMATS:
-        raise ValueError(
-            f"unknown spatial-code format {spatial_code_format!r}; "
-            f"expected {SPATIAL_CODE_FORMATS}"
-        )
-    directory = _combined_directory(
-        CODES_ROOT / MODEL,
-        depth,
-        input_selection,
-        tracking,
-        frame_count,
-        allow_video=True,
-    )
-    return str(directory / spatial_code_format)
-
-
-def spatial_code_path(
-    scene,
-    depth,
-    input_selection,
-    tracking,
-    frame_count=FRAMES_PER_VIDEO,
-    spatial_code_format="explicit",
-):
-    """Return the final spatial-code JSON path for one scene."""
-    directory = spatial_code_model_dir(
-        depth, input_selection, tracking, frame_count, spatial_code_format
-    )
-    return str(Path(directory) / f"{scene}.json")

encoder/geometric.py

@@ -1,2333 +0,0 @@
-"""Geometric assembler (runs in the pipeline venv). Imported by encoder/render.py.
-
-Pure math/assembly -- builds the per-instance spatial code (object positions/sizes, pairwise
-distances, closeness ranks, room outline, camera trajectory, appearance order) FROM
-already-computed depth/pose/masks. Does NOT run DA3 or SAM3, and does not call cache_or_load()
--- that's run.py's job entirely (the only file that calls the actual model-inference functions).
-Callers may provide raw depth/intr/c2w/conf/ftimes/per inputs or canonical world-space
-geometry; both feed build_compact_spatial_code() (see its own docstring for how it handles
-that duality). The explicit schema is no longer built independently: it is a strict derivation
-of the compact schema (build_explicit_spatial_code() calls build_compact_spatial_code() first,
-then reads every explicit value directly off compact's own oriented boxes and floor polygons --
-positions/dimensions/counts/appearance-order are direct subsets, and the distance table is
-computed purely from compact's 3D oriented boxes). This guarantees the two schemas can never
-silently disagree about the same scene's geometry.
-
-Formerly this file called into perceptual.py (as a dynamically-loaded `pl` module) for its own
-geometry helpers -- build_instances, room_gravity, answer_closest_distance, and everything else
-in this file below _room_outline(). Those functions are now merged in directly, verbatim, since
-they were never DA3/SAM3 calls -- they're geometric computations over already-extracted
-depth/masks, which is exactly this file's job. perceptual.py's OTHER half (the actual
-model-calling functions) moved to run.py instead; perceptual.py itself no longer exists.
-
-The spatial code is the sole spatial representation the downstream VLM sees; no answer engine
-is computed here (the harness runs the model).
-"""
-
-from __future__ import annotations
-
-import os
-import json
-import numpy as np
-import cv2
-
-# ==========================================================================================
-# CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
-# affect only the math below (build_instances/backproject_frame/etc.), never model inference.
-# ==========================================================================================
-
-SCHEMA = [
-    "x",
-    "y",
-    "z",
-    "e1",
-    "e2",
-    "e3",
-    "px",
-    "pz",
-    "size_median",
-    "size_IQR",
-    "time",
-    "n",
-]  # legacy row schema, see to_labeled()
-KD_WORKERS = max(1, int(os.environ.get("VSI_KD_WORKERS", "4")))
-# Batch workers set VSI_KD_WORKERS from their per-process CPU budget. Keeping a
-# bounded default avoids pathological all-core thread spawning for small queries.
-MIN_INSTANCE_PTS = (
-    1  # bare geometry floor only: need >=1 valid depth pixel to place a 3D point.
-)
-# NO quality filtering / dedup -- count = exactly SAM3's tracked masklets (honest)
-FLOOR_BAND = (
-    0.15  # m above the floor to count as floor-level (LEGACY -- currently unreferenced;
-)
-# compute_floor_area now uses the RANSAC gravity plane directly instead)
-# ---- geometry-cleanup levers (improve abs_distance etc.; env-tunable) ----
-# DEPTH_COHERENCE (Tukey-fence bleed removal): SAFE + helpful everywhere -> default ON.
-#   ablation: ARKit abs_distance 0.757->0.729 (no harm), ScanNet++ d755 0.443->0.486 (helps).
-# CONF_PCT (per-frame confidence percentile): noisy-dataset ONLY -> default OFF.
-#   helps ScanNet++ distance more (~0.56) but DESTROYS clean ARKit (0.757->0.429). Opt in via VSI_CONF_PCT=55.
-CONF_PCT = float(os.environ.get("VSI_CONF_PCT", "0"))
-DEPTH_COHERENCE = os.environ.get("VSI_DEPTH_COHERENCE", "1") == "1"
-# cut mask-bleed at per-frame depth edges. Default OFF: it's a NO-OP on the dominant failure (same-depth bleed
-# -- adjacent objects at similar range have no depth edge), and only helps depth-SEPARATED bleed. Enable per-need.
-DEPTH_EDGE_REFINE = os.environ.get("VSI_DEPTH_EDGE_REFINE", "0") == "1"
-# MASK_REFINE (appearance-guided boundary snap): uses the RGB color edge to clip same-depth mask bleed that
-#   depth can't see. Principled + cheap (CPU, no model). Default OFF until validated; enable via VSI_MASK_REFINE=1.
-MASK_REFINE = os.environ.get("VSI_MASK_REFINE", "0") == "1"
-
-
-# ==========================================================================================
-# ROOM/OBJECT GEOMETRY -- gravity, floor basis, per-instance spatial-code records. Merged in
-# from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def to_labeled(objects, floor_area):
-    """LEGACY per-class summary (kept for --format array-compat). Superseded by to_spatial_code."""
-    out = {"objects": {}}
-    for cls, row in objects.items():
-        d = dict(zip(SCHEMA, row))
-        out["objects"][cls] = {
-            "count": int(d["n"]),
-            "centroid_meters": {"x": d["x"], "y": d["y"], "z": d["z"]},
-            "longest_dimension_meters": {
-                "median": d["size_median"],
-                "iqr": d["size_IQR"],
-            },
-            "centroid_spread": {
-                "eigenvalues": [d["e1"], d["e2"], d["e3"]],
-                "principal_axis_xz": [d["px"], d["pz"]],
-            },
-            "first_seen_seconds": d["time"],
-        }
-    out["room"] = {"floor_area_square_meters": floor_area}
-    return out
-
-
-def room_up_axis(instances, c2w):
-    """up axis = smallest-extent axis of all object points; sign from gravity (floor->camera).
-    Floor = densest horizontal slab; cameras are always above it, which fixes the sign.
-    Returns (axis_index, signed_unit_vector)."""
-    points = np.concatenate([i["pts"] for v in instances.values() for i in v], 0)
-    ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-    up = int(np.argmin(ext))
-    h, edges = np.histogram(points[:, up], bins=80)
-    floor = 0.5 * (edges[h.argmax()] + edges[h.argmax() + 1])  # densest slab = floor
-    cam_up = c2w[:, :3, 3][:, up].mean()
-    e = np.zeros(3, np.float32)
-    e[up] = 1.0 if cam_up > floor else -1.0
-    return up, e
-
-
-def room_gravity(
-    depth, intr, c2w, conf, conf_pct=40, stride=12, fstride=15, iters=300, thr=0.05
-):
-    """Robust UP vector = normal of the RANSAC floor plane (a real physical plane), oriented toward
-    the cameras. Works when the reconstruction is tilted/drifted (ScanNet++) where argmin-extent fails.
-    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
-    """
-    points = []
-    for f in range(0, len(depth), fstride):
-        height, width = depth[f].shape
-        ys, xs = np.mgrid[0:height:stride, 0:width:stride]
-        ys = ys.ravel()
-        xs = xs.ravel()
-        z = depth[f][ys, xs]
-        ok = (z > 0) & np.isfinite(z)
-        if conf is not None and conf_pct > 0:
-            ok &= conf[f][ys, xs] >= np.percentile(conf[f], conf_pct)
-        ys, xs, z = ys[ok], xs[ok], z[ok]
-        if not len(z):
-            continue
-        intrinsics = intr[f]
-        camera_points = np.stack(
-            [
-                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
-                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
-                z,
-            ],
-            1,
-        )
-        points.append((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3])
-    points = np.concatenate(points).astype(np.float64) if points else np.zeros((0, 3))
-    cam = c2w[:, :3, 3].mean(0)
-    if len(points) < 100:  # fallback to axis-extent
-        ext = (
-            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-            if len(points)
-            else np.ones(3)
-        )
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return g, ax
-    rng = np.random.RandomState(0)
-    best = None
-    best_score = -1
-    for _ in range(iters):
-        a, b, c = points[rng.choice(len(points), 3, False)]
-        nrm = np.cross(b - a, c - a)
-        ln = np.linalg.norm(nrm)
-        if ln < 1e-6:
-            continue
-        nrm /= ln
-        d = -nrm @ a
-        side = points @ nrm + d
-        ninl = int((np.abs(side) < thr).sum())
-        if ninl < 50:
-            continue
-        score = ninl * max(
-            np.mean(side > thr), np.mean(side < -thr)
-        )  # big + one-sided = floor
-        if score > best_score:
-            best_score = score
-            best = (nrm, d)
-    if best is None:
-        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return g, ax
-    nrm, d = best
-    if (cam @ nrm + d) < 0:
-        nrm = -nrm  # orient toward cameras (up)
-    return nrm.astype(np.float32), int(np.argmax(np.abs(nrm)))
-
-
-def pos3(rec):
-    """Read either legacy numeric or current unit-string position formatting."""
-    p = rec.get("position") or {}
-
-    def meters(current, legacy):
-        value = p.get(current, p.get(legacy, 0.0))
-        if isinstance(value, str):
-            if value.endswith(" meters"):
-                value = value[: -len(" meters")]
-            value = value.strip()
-        return float(value)
-
-    return [
-        meters("x coordinate", "floor_x_meters"),
-        meters("y coordinate", "floor_y_meters"),
-        meters("height above floor", "height_above_floor_meters"),
-    ]
-
-
-def _floor_basis(up_vec):
-    """Orthonormal floor basis (u, v horizontal; g = up) from the gravity vector. u is the OLD
-    floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
-    differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
-    rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
-    """
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-    up_ax = int(np.argmax(np.abs(g)))
-    floor_axes = [
-        a for a in range(3) if a != up_ax
-    ]  # the two world axes the old frame used
-    e0 = np.zeros(3)
-    e0[floor_axes[0]] = 1.0  # old floor_x world axis
-    u = e0 - (e0 @ g) * g
-    u = u / (np.linalg.norm(u) + 1e-12)  # project it into the gravity plane
-    v = np.cross(g, u)
-    if v[floor_axes[1]] < 0:
-        v = -v  # keep floor_y sign aligned with the old axis
-    return u, v, g
-
-
-def _floor_level(points, gravity, v2=None):
-    """Reference floor estimator shared by every model representation.
-
-    The supplied geometry uses the densest gravity-height slab for its reproducible v1
-    behavior and the robust second percentile for v2.  Keep that switch here, after model
-    adapters have produced world points, so it cannot become model-specific.
-    """
-    heights = np.asarray(points, np.float64) @ np.asarray(gravity, np.float64)
-    heights = heights[np.isfinite(heights)]
-    if not len(heights):
-        return 0.0
-    if v2 is None:
-        v2 = os.environ.get("VSI_CODE_V2") == "1"
-    if v2:
-        return float(np.percentile(heights, 2))
-    counts, edges = np.histogram(heights, bins=80)
-    index = int(counts.argmax())
-    return float(0.5 * (edges[index] + edges[index + 1]))
-
-
-# ==========================================================================================
-# DETERMINISTIC ANSWER LAYER (parameter-free; validated on VSI GT). Reads the in-memory
-# instances (pos for direction/route, point clouds for distance). Merged in from
-# perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def _find_cls(name, classes):
-    """Mirrors symbolic/solver.py's _find_class exactly (see its docstring): word-TOKEN
-    subset, not raw character substring -- "washer" must not match "dishwasher" just
-    because the characters appear inside it (2026-07-26 fix, found via the citation-
-    fidelity audit)."""
-    name = name.strip().lower()
-    for c in classes:
-        if c == name or c.replace(" ", "") == name.replace(" ", ""):
-            return c
-    name_tokens = set(name.split())
-    for c in classes:
-        class_tokens = set(c.split())
-        if (
-            name_tokens
-            and class_tokens
-            and (name_tokens <= class_tokens or class_tokens <= name_tokens)
-        ):
-            return c
-    return None
-
-
-def _rep(insts):
-    """representative instance = most observed points (best-segmented, validated 8/8 on direction)."""
-    return max(insts, key=lambda i: i["n"])
-
-
-def answer_rel_direction(point_a, point_b, point_c, up_vec, up_ax, mode="hard"):
-    """Standing at A facing B, where is C? front/back=dot(C-A,fwd); left/right=dot(C-A, up x fwd).
-    Right-handed world (OpenCV cam frame + det+1 c2w) makes up x fwd = left a fixed identity.
-    Projection uses the gravity VECTOR (v-(v.g)g), so a tilted floor (ScanNet++) is handled; for an
-    axis-aligned up this reduces to zeroing that axis (ARKit unchanged)."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-
-    def fl(v):
-        w = v.astype(np.float64)
-        return w - (w @ g) * g
-
-    fwd = fl(point_b - point_a)
-    n = np.linalg.norm(fwd)
-    if n < 1e-6:
-        return None
-    fwd /= n
-    left = np.cross(g, fwd)
-    left /= np.linalg.norm(left) + 1e-9
-    d = fl(point_c - point_a)
-    f = float(d @ fwd)
-    lateral = float(d @ left)
-    if mode == "medium":
-        if abs(np.degrees(np.arctan2(lateral, f))) >= 135:
-            return "back"
-        return "left" if lateral > 0 else "right"
-    return f"{'front' if f > 0 else 'back'}-{'left' if lateral > 0 else 'right'}"
-
-
-def _classify_turn(h_in, h_out, up_vec, up_ax):
-    """rotation h_in->h_out in floor plane -> turn left/right/back (135deg = VSI's own 'back' cutoff)."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-
-    def fl(v):
-        w = v.astype(np.float64)
-        return w - (w @ g) * g
-
-    a, b = fl(h_in), fl(h_out)
-    na, nb = np.linalg.norm(a), np.linalg.norm(b)
-    if na < 1e-6 or nb < 1e-6:
-        return None
-    a /= na
-    b /= nb
-    ang = np.degrees(np.arctan2(float(up_vec @ np.cross(a, b)), float(a @ b)))
-    if abs(ang) >= 135:
-        return "turn back"
-    return "turn left" if ang > 0 else "turn right"
-
-
-def answer_route(ql, cents, up_vec, up_ax):
-    """Chain the turn primitive over the waypoint sequence -> ordered ['turn left/right/back', ...]."""
-    import re as _re
-
-    m = _re.search(r"beginning at the (.+?) (?:and )?facing the (.+?)\.", ql)
-    if not m:
-        return None
-
-    def position(name):
-        class_name = _find_cls(name, cents)
-        return cents[class_name] if class_name else None
-
-    steps_txt = ql.split(":", 1)[1] if ":" in ql else ql
-    steps = _re.findall(
-        r"\d+\.\s*(\[please fill in\]|Go forward until the [^0-9\[]+?)(?=\s*\d+\.|$)",
-        steps_txt,
-    )
-    cur_pos = position(m.group(1).strip())
-    if cur_pos is None:
-        return None
-    fac = position(m.group(2).strip())
-    cur_head = (fac - cur_pos) if fac is not None else None
-    turns = []
-    i = 0
-    while i < len(steps):
-        s = steps[i].strip()
-        if s.startswith("Go forward"):
-            tp = position(_re.sub(r"^Go forward until the ", "", s).strip().rstrip("."))
-            if tp is not None:
-                cur_head = tp - cur_pos
-                cur_pos = tp
-        else:
-            nxt = next(
-                (
-                    _re.sub(r"^Go forward until the ", "", steps[j].strip())
-                    .strip()
-                    .rstrip(".")
-                    for j in range(i + 1, len(steps))
-                    if steps[j].strip().startswith("Go forward")
-                ),
-                None,
-            )
-            tp = position(nxt) if nxt else None
-            if tp is None or cur_head is None:
-                turns.append(None)
-            else:
-                turns.append(_classify_turn(cur_head, tp - cur_pos, up_vec, up_ax))
-                cur_head = tp - cur_pos
-        i += 1
-    return turns
-
-
-# ==========================================================================================
-# POINT-CLOUD CLEANING + DISTANCE ANSWERS -- outlier removal, closest-distance queries. Merged
-# in from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def _sor(pts, k=16, std=2.0, cap=4000):
-    """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
-    mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
-    """
-    from scipy.spatial import cKDTree
-
-    if len(pts) < k + 2:
-        return pts
-    rs = np.random.RandomState(0)
-    points = pts if len(pts) <= cap else pts[rs.choice(len(pts), cap, False)]
-    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
-    md = d[:, 1:].mean(1)
-    return points[md <= md.mean() + std * md.std()]
-
-
-def _main_cluster(pts):
-    """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
-    object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
-    """
-    from scipy.spatial import cKDTree
-
-    if len(pts) < 30:
-        return pts
-    tree = cKDTree(pts)
-    nn, _ = tree.query(pts, k=2)
-    eps = 3.0 * float(np.median(nn[:, 1]))  # 3x median NN gap (data-derived)
-    pairs = tree.query_pairs(eps, output_type="ndarray")
-    if len(pairs) == 0:
-        return pts
-    parent = np.arange(len(pts))
-
-    def find(x):
-        r = x
-        while parent[r] != r:
-            r = parent[r]
-        while parent[x] != r:
-            parent[x], x = r, parent[x]
-        return r
-
-    for a, b in pairs:
-        ra, rb = find(int(a)), find(int(b))
-        if ra != rb:
-            parent[ra] = rb
-    roots = np.array([find(i) for i in range(len(pts))])
-    v, cnt = np.unique(roots, return_counts=True)
-    return pts[roots == v[cnt.argmax()]]
-
-
-def _clean(inst, cap=4000):
-    """Outlier removal self-calibrated from the pipeline's OWN per-object signals -- no universal constant,
-    no benchmark knob. Cached on the instance so the O(classes^2) distance table cleans each object once.
-      (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
-          object's OWN median confidence (data-derived cut);
-      (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
-    """
-    if inst.get("_cleanpts") is not None:
-        return inst["_cleanpts"]
-    pts = inst["pts"]
-    conf = inst.get("conf")
-    rs = np.random.RandomState(0)
-    if len(pts) > cap:
-        idx = rs.choice(len(pts), cap, False)
-        pts = pts[idx]
-        conf = conf[idx] if conf is not None else None
-    if conf is not None and len(conf) > 20:  # self-calibrating: object's OWN median
-        keep = conf >= np.median(conf)
-        if keep.sum() >= 10:
-            pts = pts[keep]
-    pts = _sor(pts, cap=cap)  # density outlier removal on the survivors
-    # NOTE: spatial de-bleeding (_main_cluster) was tried and REVERTED -- "largest cluster = the object" is
-    # not guaranteed; when an object's near edge splits off it drops the true closest part (overshoot). You
-    # cannot post-hoc recover the true object from a bleeding mask in 3D -- that needs better SOURCE masks.
-    inst["_cleanpts"] = pts
-    return pts
-
-
-def answer_closest_distance(instances_a, instances_b, k=4000):
-    """Closest distance between the two objects' point clouds ('closest point of each object'). Points are
-    cleaned by _clean (self-calibrated per-object confidence + density) then exact nearest-neighbor min via
-    KD-tree, so mask-bleed/speckle can't collapse the answer. NOTE: VSI's GT is box-to-box on CLEAN annotation
-    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
-    """
-    points_a = _clean(_rep(instances_a), cap=k)
-    points_b = _clean(_rep(instances_b), cap=k)
-    if len(points_a) == 0 or len(points_b) == 0:
-        return float("inf")
-    from scipy.spatial import cKDTree
-
-    if len(points_a) <= len(points_b):
-        d, _ = cKDTree(points_a).query(points_b, k=1, workers=KD_WORKERS)
-    else:
-        d, _ = cKDTree(points_b).query(points_a, k=1, workers=KD_WORKERS)
-    return float(d.min())
-
-
-# ==========================================================================================
-# MASK/DEPTH CLEANUP + BACK-PROJECTION -- per-frame refinement before points enter an
-# instance's point cloud. Merged in from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def depth_edges(depth_f, valid_f):
-    """Per-frame depth-DISCONTINUITY map: gradient magnitude above median + 3*MAD over the valid pixels.
-    The threshold is data-derived (robust, universal statistical cut -- NOT benchmark-tuned). These edges are
-    where mask-bleed crosses onto an adjacent object at a different depth."""
-    if valid_f.sum() < 100:
-        return np.zeros_like(depth_f, bool)
-    d = np.where(valid_f, depth_f, np.median(depth_f[valid_f]))
-    gy, gx = np.gradient(d)
-    grad = np.hypot(gx, gy)
-    g = grad[valid_f]
-    med = np.median(g)
-    mad = np.median(np.abs(g - med)) + 1e-9
-    return (grad > med + 3.0 * 1.4826 * mad) & valid_f
-
-
-try:
-    _GUIDED = (
-        cv2.ximgproc.guidedFilter
-    )  # opencv-contrib; appearance-guided boundary snap
-except AttributeError:
-    _GUIDED = None
-
-
-def refine_mask(mask, rgb):
-    """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
-    bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
-    cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
-    """
-    if mask.shape[:2] != rgb.shape[:2]:
-        mask = cv2.resize(
-            mask.astype(np.uint8),
-            (rgb.shape[1], rgb.shape[0]),
-            interpolation=cv2.INTER_NEAREST,
-        ).astype(bool)
-    a = int(mask.sum())
-    if a < 60:  # too small to refine meaningfully -> 1px erode as before
-        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
-        return me if me.any() else mask
-    if _GUIDED is not None:
-        r = max(
-            4, int(round(0.02 * float(np.hypot(*mask.shape[:2]))))
-        )  # radius ~2% of frame diagonal
-        eps = (
-            float(np.var(rgb.astype(np.float32) / 255.0)) * 0.01 + 1e-6
-        )  # smoothness ~ image color variance
-        soft = _GUIDED(rgb, mask.astype(np.float32), r, eps)
-        out = soft > 0.5
-        return out if out.sum() >= 0.4 * a else mask  # majority guard: don't over-carve
-    # fallback (base opencv, no ximgproc): grabCut seeded FG=mask, PR_FG=dilated ring, BG=far exterior
-    try:
-        gc = np.full(mask.shape[:2], cv2.GC_PR_BGD, np.uint8)
-        dil = cv2.dilate(mask.astype(np.uint8), np.ones((15, 15), np.uint8), 1).astype(
-            bool
-        )
-        er = cv2.erode(mask.astype(np.uint8), np.ones((5, 5), np.uint8), 1).astype(bool)
-        gc[dil] = cv2.GC_PR_FGD
-        gc[er] = cv2.GC_FGD
-        bgm = np.zeros((1, 65), np.float64)
-        fgm = np.zeros((1, 65), np.float64)
-        cv2.grabCut(rgb, gc, None, bgm, fgm, 3, cv2.GC_INIT_WITH_MASK)
-        out = (gc == cv2.GC_FGD) | (gc == cv2.GC_PR_FGD)
-        return out if 0.4 * a <= out.sum() <= 1.5 * a else mask
-    except Exception:
-        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
-        return me if me.any() else mask
-
-
-def backproject_frame(
-    depth_f,
-    intrinsics,
-    c2w_f,
-    mask_f,
-    conf_f=None,
-    conf_thr=0.0,
-    valid_f=None,
-    return_conf=False,
-    edges_f=None,
-):
-    """Return (M,3) world points for the masked pixels of one frame (c2w_f = cam->world 4x4).
-    valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
-    return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
-    edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
-    """
-    height, width = depth_f.shape
-    empty = (
-        (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
-        if return_conf
-        else np.empty((0, 3), np.float32)
-    )
-    if mask_f.shape != (height, width):
-        mask_f = cv2.resize(
-            mask_f.astype(np.uint8), (width, height), interpolation=cv2.INTER_NEAREST
-        ).astype(bool)
-    if valid_f is None:
-        valid_f = np.isfinite(depth_f) & (depth_f > 0)
-    m = mask_f & valid_f
-    if conf_f is not None and conf_thr > 0:
-        m &= conf_f >= conf_thr
-    if (
-        edges_f is not None and m.sum() >= 30
-    ):  # keep the largest depth-coherent piece of the mask
-        from scipy import ndimage
-
-        lab, nlab = ndimage.label(m & ~edges_f)
-        if nlab >= 1:
-            sizes = np.bincount(lab.ravel())
-            sizes[0] = 0
-            big = int(sizes.argmax())
-            if (
-                sizes[big] >= 0.5 * m.sum()
-            ):  # object is the MAJORITY piece (bleed is a minority)
-                m = lab == big
-    if not m.any():
-        return empty
-    ys, xs = np.nonzero(m)
-    z = depth_f[ys, xs]
-    if DEPTH_COHERENCE and len(z) >= 8:
-        # an object is a coherent depth surface; floor/background BLEED pixels are depth outliers.
-        # Drop them via the standard Tukey fence (1.5*IQR) on the masked region's depths -- parameter-free.
-        q1, q3 = np.percentile(z, [25, 75])
-        iqr = q3 - q1
-        keep = (z >= q1 - 1.5 * iqr) & (z <= q3 + 1.5 * iqr)
-        if keep.sum() >= 1:
-            ys, xs, z = ys[keep], xs[keep], z[keep]
-    fx, fy, cx, cy = (
-        intrinsics[0, 0],
-        intrinsics[1, 1],
-        intrinsics[0, 2],
-        intrinsics[1, 2],
-    )
-    camera_points = np.stack(
-        [(xs - cx) * z / fx, (ys - cy) * z / fy, z], axis=1
-    )  # camera coords
-    world_points = (c2w_f[:3, :3] @ camera_points.T).T + c2w_f[:3, 3]  # -> world
-    if return_conf:
-        cw = (
-            conf_f[ys, xs].astype(np.float32)
-            if conf_f is not None
-            else np.ones(len(ys), np.float32)
-        )
-        return world_points.astype(np.float32), cw
-    return world_points.astype(np.float32)
-
-
-# ==========================================================================================
-# INSTANCE BUILDING -- oriented extent, 3D box-overlap re-identification, and the main
-# build_instances() driver that turns per-frame masks into per-class 3D instances. Merged in
-# from perceptual.py, verbatim.
-# ==========================================================================================
-
-
-def robust_centroid_extent(pts, up_axis=None):
-    """median centroid + ORIENTED robust extent.
-    If up_axis is given: YAW-ONLY oriented extent -- rotation is found by 2D PCA on the
-    floor-projected points only, with the up axis left untouched. This matches VSI-Bench's
-    own annotation convention for indoor scans (ScanNet/ARKitScenes OrientedBoundingBox
-    objects follow a Manhattan-world assumption: rotated only around the vertical axis,
-    never tilted). Unconstrained 3D PCA (the previous behavior) can chase noise on the
-    vertical axis for flat/elongated objects and drift away from the true yaw.
-    If up_axis is None (unknown at the call site): falls back to unconstrained 3D PCA.
-    Either way: parameter-free, rotation-invariant in-plane, p2..p98 robust extent."""
-    c = np.median(pts, axis=0)
-    centered = pts - c
-    if len(centered) > 5000:  # PCA on a sample (deterministic)
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    if up_axis is not None:
-        floor_axes = [i for i in range(3) if i != up_axis]
-        floor_points = centered[:, floor_axes]
-        try:
-            _, _, floor_rotation = np.linalg.svd(
-                floor_points - floor_points.mean(0), full_matrices=False
-            )
-            proj_floor = (
-                floor_points @ floor_rotation.T
-            )  # (N,2) along the object's own floor-plane axes
-        except np.linalg.LinAlgError:
-            proj_floor = floor_points
-        up_col = centered[:, up_axis : up_axis + 1]  # up axis untouched (yaw-only)
-        proj = np.concatenate([proj_floor, up_col], axis=1)
-    else:
-        try:
-            _, _, rotation = np.linalg.svd(
-                centered - centered.mean(0), full_matrices=False
-            )
-            proj = centered @ rotation.T  # coordinates along principal axes
-        except np.linalg.LinAlgError:
-            proj = centered
-    lo = np.percentile(proj, 2, axis=0)
-    hi = np.percentile(proj, 98, axis=0)
-    ext = np.maximum(hi - lo, 0.0)
-    dims = np.sort(ext)[::-1]  # the object's 3 oriented side lengths, longest first
-    return c.astype(np.float32), float(dims[0]), dims
-
-
-def _aabb(pts):
-    """robust (p2..p98) axis-aligned 3D box of an instance's world points."""
-    return np.percentile(pts, 2, axis=0), np.percentile(pts, 98, axis=0)
-
-
-def merge_by_box_overlap(insts, up_axis=None):
-    """Parameter-free 3D re-identification, with a temporal-exclusion gate.
-
-    SAM3 (a 2D tracker) emits a NEW masklet each time the camera revisits an object, so one
-    physical object -> several masklets at the same 3D location. We fuse two same-class masklets
-    iff BOTH:
-      (a) their measured 3D boxes overlap (or one centroid is inside the other) -- same volume, and
-      (b) they NEVER appear in the same frame -- temporal exclusion.
-    (b) is the key parameter-free invariant: two masklets co-visible in one frame were tracked by
-    SAM3 as distinct objects in that frame, so they ARE distinct (e.g. two chairs around a table);
-    we must never merge them, even if depth noise makes their boxes overlap. A revisit-duplicate,
-    by contrast, lives in DISJOINT frames. Both tests are exact/measured -- NO tuned threshold.
-    """
-    n = len(insts)
-    if n <= 1:
-        return insts
-    # Precompute the FULL pairwise box-match as one vectorized boolean matrix. With the per-frame
-    # batched detector a class can have 100+ raw instances; the old O(n^3) loop called np.all-based
-    # box_match millions of times. Here every pairwise test is one broadcast -> O(1) lookups below.
-    lo = np.stack([_aabb(i["pts"])[0] for i in insts]).astype(np.float32)  # (n,3)
-    hi = np.stack([_aabb(i["pts"])[1] for i in insts]).astype(np.float32)  # (n,3)
-    cents = np.stack([i["centroid"] for i in insts]).astype(np.float32)  # (n,3)
-    overlap = (hi[:, None, :] >= lo[None, :, :]).all(-1) & (
-        hi[None, :, :] >= lo[:, None, :]
-    ).all(-1)
-    ins = (cents[:, None, :] >= lo[None, :, :]).all(-1) & (
-        cents[:, None, :] <= hi[None, :, :]
-    ).all(-1)
-    match = (
-        overlap | ins | ins.T
-    )  # box_match[i,j]: same 3D volume (identical semantics to old code)
-    # group-level agglomeration: merge two groups only if their COMBINED frame sets are disjoint
-    # (so no two co-visible masklets ever land in one object) AND some cross-pair shares a 3D volume.
-    groups = [
-        {"members": [i], "frames": set(insts[i].get("frames", set()))} for i in range(n)
-    ]
-    changed = True
-    while changed:
-        changed = False
-        for a in range(len(groups)):
-            for b in range(a + 1, len(groups)):
-                if (
-                    groups[a]["frames"] & groups[b]["frames"]
-                ):  # co-visible -> distinct objects
-                    continue
-                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
-                    groups[a]["members"] += groups[b]["members"]
-                    groups[a]["frames"] |= groups[b]["frames"]
-                    groups.pop(b)
-                    changed = True
-                    break
-            if changed:
-                break
-    merged = []
-    for g in groups:
-        idxs = g["members"]
-        pts = np.concatenate([insts[k]["pts"] for k in idxs], 0)
-        cpts = np.concatenate(
-            [
-                insts[k].get("conf", np.ones(len(insts[k]["pts"]), np.float32))
-                for k in idxs
-            ],
-            0,
-        )
-        best = max(
-            (insts[k]["best_pts"] for k in idxs), key=len
-        )  # largest single obs in the group
-        c, longest, dims = robust_centroid_extent(
-            best, up_axis
-        )  # size+pos+3 oriented dims from best view (#2/#4)
-        merged.append(
-            {
-                "centroid": c,
-                "size": longest,
-                "dims": dims,
-                "first_time": min(insts[k]["first_time"] for k in idxs),
-                "pts": pts,
-                "conf": cpts,
-                "best_pts": best,
-                "observations": [
-                    observation
-                    for k in idxs
-                    for observation in insts[k].get("observations", [insts[k]["pts"]])
-                ],
-                "frames": g["frames"],
-                "n": sum(insts[k]["n"] for k in idxs),
-                "nframes": len(g["frames"]),
-                "oids": [oid for k in idxs for oid in insts[k].get("oids", [])],
-            }
-        )  # track persistence (evidence strength)
-    return merged
-
-
-def build_instances(
-    per_class, depth, intr, c2w, conf, frame_times, frame_paths=None, up_axis=None
-):
-    """-> {class: [ {centroid(3), size(longest dim), first_time, npts} ]}
-    up_axis: if known (from room_gravity, computed BEFORE this call), threads through to
-    robust_centroid_extent for yaw-only oriented sizing. If None, size falls back to
-    unconstrained 3D PCA."""
-    out = {}
-    stats = {}
-    nframes = len(depth)
-    # precompute each frame's valid-depth mask ONCE (was recomputed per mask -> per class).
-    valid = {}
-    edges = {}
-    rgb = {}
-    used_frames = {fi for frames in per_class.values() for fi in frames if fi < nframes}
-    for fi in used_frames:
-        valid[fi] = np.isfinite(depth[fi]) & (depth[fi] > 0)
-        edges[fi] = depth_edges(depth[fi], valid[fi]) if DEPTH_EDGE_REFINE else None
-        if MASK_REFINE and frame_paths and fi < len(frame_paths):
-            im = cv2.imread(frame_paths[fi])  # BGR; guidedFilter/grabCut want 3ch uint8
-            rgb[fi] = (
-                cv2.resize(im, (depth[fi].shape[1], depth[fi].shape[0]))
-                if im is not None
-                else None
-            )
-    for cls, frames in per_class.items():
-        # peak co-visibility: max distinct masklets SAM3 tracks SIMULTANEOUSLY in any one frame.
-        # geometry-free, parameter-free, immune to revisit over-count; provable lower bound on count.
-        peak = max((len(objs) for objs in frames.values()), default=0)
-        # gather world points + first-seen time + frame set per obj_id (SAM3 track id = masklet)
-        pts_by_id, conf_by_id, first_t, frames_by_id = {}, {}, {}, {}
-        # px_by_id: (fidx, frame_time, mask_pixel_count) per obj_id, for appearance-order timing.
-        # VSI-Bench's own GT defines "first appearance" as the timestamp where an object's pixel
-        # count crosses a threshold (paper appendix B.1) -- NOT the first frame with any pixel at
-        # all. A single stray mask-bleed/false-positive pixel would otherwise register as "first
-        # seen" far too early. The threshold is self-calibrated per instance (that instance's OWN
-        # median observed pixel count across its frames), same convention as _clean's median cut.
-        px_by_id = {}
-        for fidx, objs in frames.items():
-            if fidx >= nframes:  # guard: SAM3 frame idx vs DA3 frames
-                continue
-            for oid, mask in objs.items():
-                if MASK_REFINE and rgb.get(fidx) is not None:
-                    me = (
-                        mask
-                        if os.environ.get("VSI_NO_REFINE") == "1"
-                        else refine_mask(mask, rgb[fidx])
-                    )  # appearance-guided boundary snap (clips same-depth bleed)
-                else:
-                    # erode 1px to drop mask-edge / background depth bleed
-                    me = cv2.erode(
-                        mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1
-                    ).astype(bool)
-                    if not me.any():
-                        me = mask
-                conf_f = conf[fidx] if conf is not None else None
-                conf_thr = (
-                    np.percentile(conf_f, CONF_PCT)
-                    if (conf_f is not None and CONF_PCT > 0)
-                    else 0.0
-                )
-                world_points, cw = backproject_frame(
-                    depth[fidx],
-                    intr[fidx],
-                    c2w[fidx],
-                    me,
-                    conf_f,
-                    conf_thr=conf_thr,
-                    valid_f=valid.get(fidx),
-                    return_conf=True,
-                    edges_f=edges.get(fidx),
-                )
-                if len(world_points):
-                    pts_by_id.setdefault(oid, []).append(world_points)
-                    conf_by_id.setdefault(oid, []).append(
-                        cw
-                    )  # per-point DA3 confidence (for _clean)
-                    frames_by_id.setdefault(oid, set()).add(
-                        fidx
-                    )  # for co-occurrence gate
-                    t = frame_times[fidx]
-                    px_by_id.setdefault(oid, []).append((fidx, t, int(me.sum())))
-        # appearance_order timing: per instance, first frame at/above its OWN median pixel count
-        for oid, obs in px_by_id.items():
-            counts = [c for _, _, c in obs]
-            thresh = float(np.median(counts))
-            crossing = [t for _, t, c in obs if c >= thresh]
-            first_t[oid] = min(crossing) if crossing else min(t for _, t, c in obs)
-        insts = []
-        for oid, plist in pts_by_id.items():
-            pts = np.concatenate(plist, 0)
-            cpts = np.concatenate(conf_by_id[oid], 0)
-            if len(pts) < MIN_INSTANCE_PTS:
-                continue
-            best = max(
-                plist, key=len
-            )  # #2/#4: largest single-frame observation (closest/most pixels)
-            bc, bsize, bdims = robust_centroid_extent(
-                best, up_axis
-            )  # size + position + 3 oriented dims from best view
-            insts.append(
-                {
-                    "centroid": bc,
-                    "size": bsize,
-                    "dims": bdims,
-                    "first_time": first_t[oid],
-                    "pts": pts,
-                    "conf": cpts,
-                    "best_pts": best,
-                    "observations": list(plist),
-                    "n": len(pts),
-                    "frames": frames_by_id[oid],
-                    # Raw SAM3 masklet id this fragment came from -- carried through every
-                    # later merge/consolidation step (never emitted in the JSON schema) so
-                    # a strong-correspondence overlay can draw SAM3's OWN per-frame
-                    # box/mask for a code instance instead of re-deriving one via 3D
-                    # projection. See encoder.geometric.instance_source_track_ids.
-                    "oids": [int(oid)],
-                }
-            )
-        raw = len(insts)
-        # 3D re-ID: fuse same-class masklets that occupy the same measured 3D volume (parameter-free).
-        insts = merge_by_box_overlap(insts, up_axis)
-        if insts:
-            out[cls] = insts
-            stats[cls] = {"raw": raw, "merged": len(insts), "peak": peak}
-    return out, stats
-
-
-# ==========================================================================================
-# PER-CLASS SUMMARY -- legacy array-schema row builder. Merged in from perceptual.py, verbatim.
-# (The room-scale floor area calculation that used to live here is gone -- the explicit
-# schema's floor area is now a direct derivation of the compact schema's floor boundary
-# polygons; see build_explicit_spatial_code() near build_compact_spatial_code().)
-# ==========================================================================================
-
-
-# ---- Per-class spatial code (legacy array-schema row) -------------------------------------
-def class_spatial_code(insts, peak=0):
-    cents = np.stack([i["centroid"] for i in insts], 0)  # (n,3)
-    sizes = np.array([i["size"] for i in insts], np.float32)
-    n = len(insts)  # merged centroids (for spatial stats)
-    count = peak if peak else n  # reported count = peak co-visibility
-    x, y, z = cents.mean(0)
-    if n == 1:
-        e1 = e2 = e3 = px = pz = 0.0
-        size_iqr = 0.0
-    else:
-        cov = np.cov(cents.T)  # 3x3
-        vals, vecs = np.linalg.eigh(cov)  # ascending
-        order = np.argsort(vals)[::-1]
-        vals = np.clip(vals[order], 0, None)
-        vecs = vecs[:, order]
-        e1, e2, e3 = vals.tolist()
-        pv = vecs[:, 0]  # principal eigenvector
-        px, pz = float(pv[0]), float(pv[2])
-        q1, q3 = np.percentile(sizes, [25, 75])
-        size_iqr = float(q3 - q1)
-    size_median = float(np.median(sizes))
-    first_time = float(min(i["first_time"] for i in insts))
-    row = [x, y, z, e1, e2, e3, px, pz, size_median, size_iqr, first_time, count]
-    row = [
-        (lambda r: 0.0 if r == 0 else r)(round(float(v), 1)) for v in row
-    ]  # kill -0.0
-    row[-1] = int(count)
-    return row
-
-
-def _reference_object_records(insts, count, u, v, g, floor_level):
-    """Object record formatter used by the original V2 spatial-code builder."""
-    ranked = sorted(insts, key=lambda i: (i["n"], i.get("nframes", 0)), reverse=True)[
-        : max(int(count), 1)
-    ]
-    recs = []
-    for it in ranked:
-        center = np.asarray(it["centroid"], np.float64)
-        points = np.asarray(it["pts"], np.float64)
-        floor_x = points @ u
-        floor_y = points @ v
-        height = points @ g - floor_level
-        recs.append(
-            {
-                "position": {
-                    "floor_x_meters": round(float(center @ u), 2),
-                    "floor_y_meters": round(float(center @ v), 2),
-                    "height_above_floor_meters": round(
-                        float(center @ g - floor_level), 2
-                    ),
-                },
-                "longest_dimension_meters": round(float(it["size"]), 2),
-                "bounding_box": {
-                    "floor_x_meters": [
-                        round(float(np.percentile(floor_x, 2)), 2),
-                        round(float(np.percentile(floor_x, 98)), 2),
-                    ],
-                    "floor_y_meters": [
-                        round(float(np.percentile(floor_y, 2)), 2),
-                        round(float(np.percentile(floor_y, 98)), 2),
-                    ],
-                    "height_above_floor_meters": [
-                        round(float(np.percentile(height, 2)), 2),
-                        round(float(np.percentile(height, 98)), 2),
-                    ],
-                },
-                "dimensions_meters": [round(float(d), 2) for d in it["dims"]],
-            }
-        )
-    return recs
-
-
-def _reference_to_spatial_code(
-    instances, stats, floor_area, up_axis, up_vec, floor_level
-):
-    """Per-instance spatial code shape from the original geometric V2 pipeline."""
-    u, v, g = _floor_basis(up_vec)
-    out = {"objects": {}}
-    for class_name, insts in instances.items():
-        count = int(stats[class_name]["peak"])
-        out["objects"][class_name] = {
-            "count": count,
-            "instances": _reference_object_records(insts, count, u, v, g, floor_level),
-        }
-    out["room"] = {"floor_area_square_meters": floor_area}
-    return out
-
-
-def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
-    """Reference floor-area computation from the original geometric pipeline."""
-    points = []
-    for frame_index in range(depth.shape[0]):
-        height, width = depth[frame_index].shape
-        rows, columns = np.mgrid[0:height:stride, 0:width:stride]
-        rows = rows.ravel()
-        columns = columns.ravel()
-        values = depth[frame_index][rows, columns]
-        keep = np.isfinite(values) & (values > 0)
-        if sky is not None:
-            keep &= ~sky[frame_index][rows, columns].astype(bool)
-        if conf is not None:
-            keep &= conf[frame_index][rows, columns] >= np.percentile(
-                conf[frame_index], 40
-            )
-        rows, columns, values = rows[keep], columns[keep], values[keep]
-        if not len(values):
-            continue
-        current = intr[frame_index]
-        camera = np.stack(
-            [
-                (columns - current[0, 2]) * values / current[0, 0],
-                (rows - current[1, 2]) * values / current[1, 1],
-                values,
-            ],
-            1,
-        )
-        world = (c2w[frame_index][:3, :3] @ camera.T).T + c2w[frame_index][:3, 3]
-        points.append(world.astype(np.float32))
-    if not points:
-        return 0.0
-    scene_points = np.concatenate(points, 0)
-    if up_vec is not None:
-        gravity = np.asarray(up_vec, np.float64)
-        gravity /= np.linalg.norm(gravity) + 1e-12
-        axis = (
-            np.array([1.0, 0.0, 0.0])
-            if abs(gravity[0]) < 0.9
-            else np.array([0.0, 1.0, 0.0])
-        )
-        u = np.cross(gravity, axis)
-        u /= np.linalg.norm(u)
-        v = np.cross(gravity, u)
-        floor_points = np.stack([scene_points @ u, scene_points @ v], 1)
-    else:
-        up_axis = int(np.argmin(scene_points.max(0) - scene_points.min(0)))
-        floor_axes = [axis for axis in range(3) if axis != up_axis]
-        floor_points = scene_points[:, floor_axes]
-    lower = np.percentile(floor_points, 0.5, 0)
-    upper = np.percentile(floor_points, 99.5, 0)
-    floor_points = floor_points[
-        (floor_points[:, 0] >= lower[0])
-        & (floor_points[:, 0] <= upper[0])
-        & (floor_points[:, 1] >= lower[1])
-        & (floor_points[:, 1] <= upper[1])
-    ]
-    if len(floor_points) < 10:
-        return 0.0
-    try:
-        import alphashape
-
-        sample = np.random.RandomState(0).choice(
-            len(floor_points), min(10000, len(floor_points))
-        )
-        return round(
-            float(alphashape.alphashape(floor_points[sample], alpha=2).area), 1
-        )
-    except Exception:
-        from scipy import ndimage
-
-        resolution = 0.10
-        rows = ((floor_points[:, 0] - floor_points[:, 0].min()) / resolution).astype(
-            int
-        )
-        columns = ((floor_points[:, 1] - floor_points[:, 1].min()) / resolution).astype(
-            int
-        )
-        grid = np.zeros((rows.max() + 3, columns.max() + 3), np.uint8)
-        grid[rows + 1, columns + 1] = 1
-        grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-        grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-        return round(float(grid.sum()) * resolution * resolution, 1)
-
-
-# ---------------------------------------------------------------------------
-
-# ==========================================================================================
-# SPATIAL CODE ASSEMBLY -- the top-level entry point this whole file exists for:
-# build_spatial_code() calls everything above to turn already-computed depth/pose/masks into
-# the final spatial code dict. Room outline + JSON writer. This section was already in
-# geometric.py before the perceptual.py merge; build_spatial_code() below is updated to call
-# the geometry functions above DIRECTLY (no `pl.` prefix -- they're plain local functions now
-# that everything is in one file), same logic, unchanged otherwise.
-# ==========================================================================================
-
-
-def _room_outline(depth, intr, c2w, conf, bu, bv):
-    """(Unemitted by explicit format; compact format derives its boundary separately. This
-    math is kept intact for reuse.) Room floor-boundary polygon from the SAME grid as
-    compute_floor_area: floor points
-    projected onto the shared gravity plane (bu, bv), 10cm grid, close 7x7, fill holes,
-    largest contour, 0.2m polygon simplification. Same (bu, bv) as objects/camera, so the
-    outline, object positions, and floor_area all live in one consistent frame."""
-    from scipy import ndimage
-
-    pts, stride = [], 8
-    for f in range(0, depth.shape[0], 3):
-        height, width = depth[f].shape
-        ys, xs = np.mgrid[0:height:stride, 0:width:stride]
-        ys = ys.ravel()
-        xs = xs.ravel()
-        z = depth[f][ys, xs]
-        ok = np.isfinite(z) & (z > 0)
-        if conf is not None:
-            ok &= conf[f][ys, xs] >= np.percentile(conf[f], 40)
-        ys, xs, z = ys[ok], xs[ok], z[ok]
-        if not len(z):
-            continue
-        intrinsics = intr[f]
-        camera_points = np.stack(
-            [
-                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
-                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
-                z,
-            ],
-            1,
-        )
-        pts.append(
-            ((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3]).astype(np.float32)
-        )
-    if not pts:
-        return []
-    world_points = np.concatenate(pts, 0)
-    points = np.stack(
-        [world_points @ bu, world_points @ bv], 1
-    )  # gravity-plane projection (same bu,bv as objects/area)
-    lo = np.percentile(points, 0.5, 0)
-    hi = np.percentile(points, 99.5, 0)
-    points = points[
-        (points[:, 0] >= lo[0])
-        & (points[:, 0] <= hi[0])
-        & (points[:, 1] >= lo[1])
-        & (points[:, 1] <= hi[1])
-    ]
-    if len(points) < 10:
-        return []
-    res = 0.10
-    x0, y0 = points[:, 0].min(), points[:, 1].min()
-    ai = ((points[:, 0] - x0) / res).astype(int)
-    bi = ((points[:, 1] - y0) / res).astype(int)
-    grid = np.zeros((ai.max() + 3, bi.max() + 3), np.uint8)
-    grid[ai + 1, bi + 1] = 1
-    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-    cs, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not cs:
-        return []
-    poly = cv2.approxPolyDP(max(cs, key=cv2.contourArea), 0.2 / res, True)[:, 0, :]
-    # cv2 contour points are (col=bi, row=ai) -> (floor_y, floor_x)
-    return [
-        {
-            "floor_x_meters": round(float((r - 1) * res + x0), 1),
-            "floor_y_meters": round(float((c - 1) * res + y0), 1),
-        }
-        for c, r in poly
-    ]
-
-
-def dump_spatial_code(code, path):
-    """Save a spatial_code.json exactly like json.dump(code, f, indent=1), EXCEPT
-    "appearance order" is written as one compact line instead of one line per entry -- it's a
-    single ordered sequence meant to be scanned, not structured data meant to be read field by
-    field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
-    """
-    body = dict(code)
-    ao = body.pop("appearance order", None)
-    text = json.dumps(body, indent=1).rstrip()
-    if ao is not None:
-        assert text.endswith("}")
-        text = text[:-1].rstrip() + ',\n "appearance order": ' + json.dumps(ao) + "\n}"
-    with open(path, "w") as f:
-        f.write(text)
-
-
-# Canonical world-space fallback used by SegVGGT and similar adapters.
-def _canonical_room_gravity(points, cameras=None, iters=300, thr=0.05):
-    """Robust UP vector = normal of the RANSAC floor plane, oriented toward the cameras."""
-    points = np.asarray(points, np.float64)
-    points = points[np.isfinite(points).all(1)]
-    if len(points) > 100000:
-        points = points[np.random.RandomState(0).choice(len(points), 100000, False)]
-    cam = (
-        np.asarray(cameras, np.float64).mean(0)
-        if cameras is not None and len(cameras)
-        else None
-    )
-    if len(points) < 100:
-        ext = (
-            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-            if len(points)
-            else np.ones(3)
-        )
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return (g, ax)
-    rng = np.random.RandomState(0)
-    best = None
-    best_score = -1
-    for _ in range(iters):
-        a, b, c = points[rng.choice(len(points), 3, False)]
-        nrm = np.cross(b - a, c - a)
-        ln = np.linalg.norm(nrm)
-        if ln < 1e-06:
-            continue
-        nrm /= ln
-        d = -nrm @ a
-        side = points @ nrm + d
-        ninl = int((np.abs(side) < thr).sum())
-        if ninl < 50:
-            continue
-        score = ninl * max(np.mean(side > thr), np.mean(side < -thr))
-        if score > best_score:
-            best_score = score
-            best = (nrm, d)
-    if best is None:
-        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
-        ax = int(np.argmin(ext))
-        g = np.zeros(3)
-        g[ax] = 1.0
-        return (g, ax)
-    nrm, d = best
-    if cam is not None and cam @ nrm + d < 0:
-        nrm = -nrm
-    return (nrm.astype(np.float32), int(np.argmax(np.abs(nrm))))
-
-
-def _canonical_floor_basis(up_vec):
-    """Orthonormal floor basis (u, v horizontal; g = up), unchanged from the old file."""
-    g = np.asarray(up_vec, np.float64)
-    g = g / (np.linalg.norm(g) + 1e-12)
-    up_ax = int(np.argmax(np.abs(g)))
-    floor_axes = [a for a in range(3) if a != up_ax]
-    e0 = np.zeros(3)
-    e0[floor_axes[0]] = 1.0
-    u = e0 - e0 @ g * g
-    u = u / (np.linalg.norm(u) + 1e-12)
-    v = np.cross(g, u)
-    if v[floor_axes[1]] < 0:
-        v = -v
-    return (u, v, g)
-
-
-def _canonical_robust_centroid_extent(pts, up_axis=None):
-    c = np.median(pts, axis=0)
-    centered = pts - c
-    if len(centered) > 5000:
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    if up_axis is not None:
-        floor_axes = [i for i in range(3) if i != up_axis]
-        floor_points = centered[:, floor_axes]
-        try:
-            _, _, floor_rotation = np.linalg.svd(
-                floor_points - floor_points.mean(0), full_matrices=False
-            )
-            proj_floor = floor_points @ floor_rotation.T
-        except np.linalg.LinAlgError:
-            proj_floor = floor_points
-        proj = np.concatenate([proj_floor, centered[:, up_axis : up_axis + 1]], 1)
-    else:
-        try:
-            _, _, rotation = np.linalg.svd(
-                centered - centered.mean(0), full_matrices=False
-            )
-            proj = centered @ rotation.T
-        except np.linalg.LinAlgError:
-            proj = centered
-    ext = np.maximum(np.percentile(proj, 98, 0) - np.percentile(proj, 2, 0), 0.0)
-    dims = np.sort(ext)[::-1]
-    return (c.astype(np.float32), float(dims[0]), dims)
-
-
-def _canonical_aabb(pts):
-    return (np.percentile(pts, 2, 0), np.percentile(pts, 98, 0))
-
-
-def _canonical_merge_by_box_overlap(insts, up_axis=None):
-    """Parameter-free 3D re-identification with temporal exclusion, unchanged."""
-    n = len(insts)
-    if n <= 1:
-        return insts
-    lo = np.stack([_canonical_aabb(i["pts"])[0] for i in insts])
-    hi = np.stack([_canonical_aabb(i["pts"])[1] for i in insts])
-    cents = np.stack([i["centroid"] for i in insts])
-    overlap = (hi[:, None] >= lo[None]).all(-1) & (hi[None] >= lo[:, None]).all(-1)
-    ins = (cents[:, None] >= lo[None]).all(-1) & (cents[:, None] <= hi[None]).all(-1)
-    match = overlap | ins | ins.T
-    groups = [
-        {"members": [i], "frames": set(insts[i].get("frames", ()))} for i in range(n)
-    ]
-    changed = True
-    while changed:
-        changed = False
-        for a in range(len(groups)):
-            for b in range(a + 1, len(groups)):
-                if groups[a]["frames"] & groups[b]["frames"]:
-                    continue
-                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
-                    groups[a]["members"] += groups[b]["members"]
-                    groups[a]["frames"] |= groups[b]["frames"]
-                    groups.pop(b)
-                    changed = True
-                    break
-            if changed:
-                break
-    out = []
-    for g in groups:
-        ii = g["members"]
-        pts = np.concatenate([insts[k]["pts"] for k in ii], 0)
-        best = max((insts[k]["best_pts"] for k in ii), key=len)
-        c, size, dims = _canonical_robust_centroid_extent(best, up_axis)
-        confs = [insts[k].get("conf") for k in ii]
-        conf = (
-            np.concatenate([x for x in confs if x is not None], 0)
-            if any((x is not None for x in confs))
-            else None
-        )
-        out.append(
-            {
-                "centroid": c,
-                "size": size,
-                "dims": dims,
-                "pts": pts,
-                "best_pts": best,
-                "observations": [
-                    observation
-                    for k in ii
-                    for observation in insts[k].get("observations", [insts[k]["pts"]])
-                ],
-                "conf": conf,
-                "frames": g["frames"],
-                "nframes": len(g["frames"]),
-                "n": sum((insts[k]["n"] for k in ii)),
-                "first_time": min((insts[k]["first_time"] for k in ii)),
-            }
-        )
-    return out
-
-
-def _canonical_sor(pts, k=16, std=2.0, cap=4000):
-    from scipy.spatial import cKDTree
-
-    if len(pts) < k + 2:
-        return pts
-    points = (
-        pts
-        if len(pts) <= cap
-        else pts[np.random.RandomState(0).choice(len(pts), cap, False)]
-    )
-    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
-    md = d[:, 1:].mean(1)
-    return points[md <= md.mean() + std * md.std()]
-
-
-def _canonical_clean(inst, cap=4000):
-    if inst.get("_cleanpts") is not None:
-        return inst["_cleanpts"]
-    pts, conf = (inst["pts"], inst.get("conf"))
-    if len(pts) > cap:
-        idx = np.random.RandomState(0).choice(len(pts), cap, False)
-        pts = pts[idx]
-        if conf is not None:
-            conf = conf[idx]
-    if conf is not None and len(conf) > 20:
-        keep = conf >= np.median(conf)
-        if keep.sum() >= 10:
-            pts = pts[keep]
-    inst["_cleanpts"] = _canonical_sor(pts, cap=cap)
-    return inst["_cleanpts"]
-
-
-# ==========================================================================================
-# COMPACT SPATIAL CODE -- reusable geometry and time primitives, with no derived answers.
-# ==========================================================================================
-
-
-COMPACT_SPATIAL_CODE_SCHEMA = {
-    "objects": {
-        "<object class>": [
-            {
-                "3D oriented bounding box": {
-                    "3D oriented bounding box center coordinates": {
-                        "components": ["x", "y", "height above floor"],
-                        "unit": "meters",
-                        "description": (
-                            "center of the 3D oriented bounding box in the shared room "
-                            "coordinate system"
-                        ),
-                    },
-                    "3D oriented bounding box dimensions": {
-                        "components": ["dimension 1", "dimension 2", "dimension 3"],
-                        "unit": "meters",
-                        "description": (
-                            "full lengths of the 3D oriented bounding box along the "
-                            "corresponding orientation unit vectors"
-                        ),
-                    },
-                    "3D oriented bounding box orientation unit vectors": {
-                        "components": [
-                            ["x", "y", "height"],
-                            ["x", "y", "height"],
-                            ["x", "y", "height"],
-                        ],
-                        "unit": None,
-                        "description": (
-                            "three perpendicular directions corresponding in order to the "
-                            "three 3D oriented bounding box dimensions"
-                        ),
-                    },
-                },
-                "first visible time": {
-                    "unit": "seconds",
-                    "description": (
-                        "earliest time at which this object instance is visibly observed"
-                    ),
-                },
-            }
-        ]
-    },
-    "room": {
-        "floor boundary polygons": [
-            {
-                "outer boundary coordinates": {
-                    "components": [["x", "y"], ["x", "y"]],
-                    "unit": "meters",
-                    "description": "ordered vertices enclosing one floor region",
-                },
-                "interior hole boundary coordinates": {
-                    "components": [[["x", "y"], ["x", "y"]]],
-                    "unit": "meters",
-                    "description": (
-                        "ordered boundaries enclosing regions excluded from the floor area"
-                    ),
-                },
-            }
-        ]
-    },
-}
-
-
-def _rounded_list(values):
-    """Round one numeric vector to stable JSON values without negative zero."""
-    return [0.0 if (value := round(float(x), 2)) == 0 else value for x in values]
-
-
-def _weighted_quantile(values, weights, quantile):
-    """Return one deterministic weighted quantile for observation consensus."""
-    values = np.asarray(values, np.float64)
-    weights = np.asarray(weights, np.float64)
-    order = np.argsort(values)
-    values, weights = values[order], weights[order]
-    cumulative = np.cumsum(weights) - 0.5 * weights
-    cumulative /= weights.sum()
-    return float(np.interp(quantile, cumulative, values))
-
-
-def _compact_oriented_box(instance, u, v, g, floor_level):
-    """Fit one floor-aligned OBB from the same per-instance math as the reference code."""
-    center = np.asarray(instance["centroid"], np.float64)
-    points = np.asarray(instance["best_pts"], np.float64)
-    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
-    centered = room_points[:, :2] - np.median(room_points[:, :2], axis=0)
-    if len(centered) > 5000:
-        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
-    try:
-        _, _, rotation = np.linalg.svd(
-            centered - centered.mean(axis=0), full_matrices=False
-        )
-    except np.linalg.LinAlgError:
-        rotation = np.eye(2)
-    first = rotation[0]
-    dominant = int(np.argmax(np.abs(first)))
-    if first[dominant] < 0:
-        first = -first
-    second = np.array([-first[1], first[0]])
-    orientation = np.array(
-        [[first[0], first[1], 0.0], [second[0], second[1], 0.0], [0.0, 0.0, 1.0]]
-    )
-    box_center = np.array([center @ u, center @ v, center @ g - floor_level])
-    box_dimensions = np.asarray(instance["dims"], np.float64)
-    return {
-        "3D oriented bounding box center coordinates": _rounded_list(box_center),
-        "3D oriented bounding box dimensions": _rounded_list(box_dimensions),
-        "3D oriented bounding box orientation unit vectors": [
-            _rounded_list(axis) for axis in orientation
-        ],
-    }
-
-
-def _contour_coordinates(contour, x_origin, y_origin, resolution):
-    """Translate one OpenCV grid contour to ordered shared-room coordinates."""
-    return [
-        _rounded_list(
-            [x_origin + (row - 1) * resolution, y_origin + (column - 1) * resolution]
-        )
-        for column, row in contour[:, 0, :]
-    ]
-
-
-def _compact_scene_points(scene):
-    """Return the same dense floor-support sample used by explicit room-area math."""
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is None:
-        return scene["scene_pts"]
-    depth = raw_inputs["depth"]
-    intrinsics = raw_inputs["intr"]
-    poses = raw_inputs["c2w"]
-    confidence = raw_inputs.get("conf")
-    points = []
-    for frame_index in range(len(depth)):
-        height, width = depth[frame_index].shape
-        rows, columns = np.mgrid[0:height:8, 0:width:8]
-        rows, columns = rows.ravel(), columns.ravel()
-        values = depth[frame_index][rows, columns]
-        keep = np.isfinite(values) & (values > 0)
-        if confidence is not None:
-            threshold = np.percentile(confidence[frame_index], 40)
-            keep &= confidence[frame_index][rows, columns] >= threshold
-        rows, columns, values = rows[keep], columns[keep], values[keep]
-        if not len(values):
-            continue
-        current = intrinsics[frame_index]
-        camera = np.stack(
-            [
-                (columns - current[0, 2]) * values / current[0, 0],
-                (rows - current[1, 2]) * values / current[1, 1],
-                values,
-            ],
-            axis=1,
-        )
-        world = poses[frame_index][:3, :3] @ camera.T
-        points.append((world.T + poses[frame_index][:3, 3]).astype(np.float32))
-    return np.concatenate(points, axis=0) if points else scene["scene_pts"]
-
-
-def _compact_floor_boundary_polygons(points, u, v, object_points=None):
-    """Extract the reference room outline as a compact floor-boundary polygon."""
-    from scipy import ndimage
-
-    points = np.asarray(points, np.float64)
-    floor_points = np.stack([points @ u, points @ v], axis=1)
-    floor_points = floor_points[np.isfinite(floor_points).all(axis=1)]
-    if len(floor_points) < 3:
-        return []
-    lower = np.percentile(floor_points, 0.5, axis=0)
-    upper = np.percentile(floor_points, 99.5, axis=0)
-    floor_points = floor_points[
-        (floor_points[:, 0] >= lower[0])
-        & (floor_points[:, 0] <= upper[0])
-        & (floor_points[:, 1] >= lower[1])
-        & (floor_points[:, 1] <= upper[1])
-    ]
-    if len(floor_points) < 3:
-        return []
-    resolution = 0.1
-    x_origin, y_origin = floor_points.min(axis=0)
-    x_max, y_max = floor_points.max(axis=0)
-    row_count = int((x_max - x_origin) / resolution) + 3
-    column_count = int((y_max - y_origin) / resolution) + 3
-    grid = np.zeros((row_count, column_count), np.uint8)
-    rows = ((floor_points[:, 0] - x_origin) / resolution).astype(int)
-    columns = ((floor_points[:, 1] - y_origin) / resolution).astype(int)
-    grid[rows + 1, columns + 1] = 1
-    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
-    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
-    contours, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return []
-    contour = cv2.approxPolyDP(
-        max(contours, key=cv2.contourArea), 0.2 / resolution, True
-    )
-    return [
-        {
-            "outer boundary coordinates": _contour_coordinates(
-                contour, x_origin, y_origin, resolution
-            ),
-            "interior hole boundary coordinates": [],
-        }
-    ]
-
-
-def _compact_duplicate_groups(instances):
-    """Group near-identical co-visible boxes that represent duplicate mask tracks."""
-    count = len(instances)
-    parent = list(range(count))
-
-    def root(index):
-        while parent[index] != index:
-            parent[index] = parent[parent[index]]
-            index = parent[index]
-        return index
-
-    def union(first, second):
-        first, second = root(first), root(second)
-        if first != second:
-            parent[second] = first
-
-    bounds = [_canonical_aabb(_canonical_clean(instance)) for instance in instances]
-    for first in range(count):
-        lower_a, upper_a = bounds[first]
-        extent_a = np.maximum(upper_a - lower_a, 1e-6)
-        volume_a = float(np.prod(extent_a))
-        for second in range(first + 1, count):
-            lower_b, upper_b = bounds[second]
-            extent_b = np.maximum(upper_b - lower_b, 1e-6)
-            volume_b = float(np.prod(extent_b))
-            intersection = np.maximum(
-                np.minimum(upper_a, upper_b) - np.maximum(lower_a, lower_b), 0.0
-            )
-            overlap = float(np.prod(intersection)) / min(volume_a, volume_b)
-            if overlap >= 0.8:
-                union(first, second)
-    groups = {}
-    for index in range(count):
-        groups.setdefault(root(index), []).append(index)
-    return list(groups.values())
-
-
-def _combine_compact_instances(instances, members, up_axis):
-    """Combine one duplicate group while retaining all evidence and earliest timing."""
-    selected = [instances[index] for index in members]
-    points = np.concatenate([instance["pts"] for instance in selected], axis=0)
-    best = max((instance["best_pts"] for instance in selected), key=len)
-    confidence = [instance.get("conf") for instance in selected]
-    confidence = (
-        np.concatenate(confidence, axis=0)
-        if all(value is not None for value in confidence)
-        else None
-    )
-    centroid, size, dimensions = _canonical_robust_centroid_extent(points, up_axis)
-    frames = set().union(*(set(instance.get("frames", ())) for instance in selected))
-    return {
-        "centroid": centroid,
-        "size": size,
-        "dims": dimensions,
-        "first_time": min(instance["first_time"] for instance in selected),
-        "pts": points,
-        "conf": confidence,
-        "best_pts": best,
-        "observations": [
-            observation
-            for instance in selected
-            for observation in instance.get("observations", [instance["pts"]])
-        ],
-        "frames": frames,
-        "n": sum(instance.get("n", len(instance["pts"])) for instance in selected),
-        "nframes": len(frames),
-        "oids": [oid for instance in selected for oid in instance.get("oids", [])],
-    }
-
-
-def _compact_instance_evidence(instance):
-    """Rank one physical-instance hypothesis by persistence and geometric support."""
-    observations = instance.get("observations", [instance["pts"]])
-    observed_points = np.array([len(observation) for observation in observations])
-    return (
-        instance.get("nframes", len(instance.get("frames", ()))),
-        len(observations),
-        float(np.median(observed_points)) if len(observed_points) else 0.0,
-        instance.get("n", len(instance["pts"])),
-    )
-
-
-def _consolidate_compact_instances(instances, stats, up_axis):
-    """Suppress duplicate tracks and retain the strongest co-visible instance set."""
-    consolidated = {}
-    for class_name, items in instances.items():
-        combined = [
-            _combine_compact_instances(items, members, up_axis)
-            for members in _compact_duplicate_groups(items)
-        ]
-        peak = int(stats.get(class_name, {}).get("peak", 0))
-        limit = min(len(combined), max(peak, 1))
-        ranked = sorted(combined, key=_compact_instance_evidence, reverse=True)
-        retained = ranked[:limit]
-        for fragment in ranked[limit:]:
-            nearest = min(
-                retained,
-                key=lambda instance: np.linalg.norm(
-                    instance["centroid"] - fragment["centroid"]
-                ),
-            )
-            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
-        consolidated[class_name] = retained
-    return consolidated
-
-
-def _compact_instances(scene, up_axis):
-    """Return consolidated physical instances for raw or canonical adapter geometry."""
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        instances, stats = build_instances(
-            raw_inputs["per"],
-            raw_inputs["depth"],
-            raw_inputs["intr"],
-            raw_inputs["c2w"],
-            raw_inputs.get("conf"),
-            raw_inputs["ftimes"],
-            up_axis=up_axis,
-        )
-    else:
-        instances = {}
-        stats = {
-            class_name: dict(values) for class_name, values in scene["stats"].items()
-        }
-        for class_name, items in scene["instances"].items():
-            measured = []
-            for item in items:
-                points = _canonical_clean(item)
-                if not len(points):
-                    points = item["pts"]
-                centroid, size, dimensions = _canonical_robust_centroid_extent(
-                    points, up_axis
-                )
-                record = dict(item)
-                record.update({"centroid": centroid, "size": size, "dims": dimensions})
-                measured.append(record)
-            instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
-    for class_name, items in instances.items():
-        stats.setdefault(class_name, {})
-        stats[class_name]["merged"] = len(items)
-    return instances, stats
-
-
-def instance_source_track_ids(scene):
-    """Return {emitted_class_name: [oids_for_instance_1, oids_for_instance_2, ...]},
-    one ordered list of raw SAM3 masklet ids per FINAL consolidated instance -- in
-    EXACTLY the rank order build_compact_spatial_code() emits instances in (same
-    (n, nframes)-descending sort, same class-name aliasing), so index i here IS the
-    "<class> {i+1}" instance id the strong correspondence overlay stamps. A raw-only
-    lookup: reruns nothing but the consolidation build_compact_spatial_code() already
-    does, just exposing the "oids" field that pipeline discards before emission (the
-    on-disk schema never carries SAM3 ids -- this function is the only place that does).
-    """
-    alias = {"coat hanger": "coat rack"}
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is None:
-        raise ValueError(
-            "instance_source_track_ids needs raw depth/intr/c2w inputs; this geometry "
-            "cache carries only canonical points (no SAM3 track ids to recover)"
-        )
-    up_vec, up_ax = room_gravity(
-        raw_inputs["depth"],
-        raw_inputs["intr"],
-        raw_inputs["c2w"],
-        raw_inputs.get("conf"),
-    )
-    instances, _stats = _compact_instances(scene, up_ax)
-    out = {}
-    for class_name, items in instances.items():
-        emitted_name = alias.get(class_name, class_name)
-        ranked = sorted(
-            items,
-            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
-            reverse=True,
-        )
-        out.setdefault(emitted_name, []).extend(item.get("oids", []) for item in ranked)
-    return out
-
-
-def build_compact_spatial_code(scene):
-    """Build reusable OBB, visibility-time, and floor-boundary primitives."""
-    alias = {"coat hanger": "coat rack"}
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        up_vec, up_ax = room_gravity(
-            raw_inputs["depth"],
-            raw_inputs["intr"],
-            raw_inputs["c2w"],
-            raw_inputs.get("conf"),
-        )
-        u, v, g = _floor_basis(up_vec)
-    else:
-        up_vec, up_ax = _canonical_room_gravity(
-            scene["scene_pts"], scene.get("cameras")
-        )
-        u, v, g = _canonical_floor_basis(up_vec)
-    instances, stats = _compact_instances(scene, up_ax)
-    all_points = np.concatenate(
-        [item["pts"] for values in instances.values() for item in values], axis=0
-    )
-    floor_level = _floor_level(all_points, g)
-    objects = {}
-    for class_name, items in instances.items():
-        emitted_name = alias.get(class_name, class_name)
-        ranked = sorted(
-            items,
-            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
-            reverse=True,
-        )
-        count = int(stats.get(class_name, {}).get("peak", 0))
-        ranked = ranked[: max(count, 1)]
-        objects.setdefault(emitted_name, []).extend(
-            {
-                "3D oriented bounding box": _compact_oriented_box(
-                    item, u, v, g, floor_level
-                ),
-                "first visible time": round(float(item["first_time"]), 2),
-            }
-            for item in ranked
-        )
-    code = {
-        "objects": objects,
-        "room": {
-            "floor boundary polygons": _compact_floor_boundary_polygons(
-                _compact_scene_points(scene), u, v
-            )
-        },
-    }
-    return code, instances, stats, up_ax, up_vec, None
-
-
-# ==========================================================================================
-# EXPLICIT SPATIAL CODE -- a strict derivation of the compact schema above. Every object
-# position/dimension/count/appearance-order value is read directly off compact's own oriented
-# boxes and "first visible time" (a direct subset, not independently recomputed); the distance
-# table is the one thing compact never stores, so it is computed here purely from compact's own
-# 3D oriented boxes -- exact surface-to-surface separation via bounded least squares (same
-# convex, closed-form-adjacent optimization symbolic/adapters.py's solver-side derivation
-# already used for compact input, now the ACTUAL on-disk construction for explicit too, so the
-# two schemas can never independently disagree about the same scene's geometry).
-# ==========================================================================================
-
-
-EXPLICIT_SPATIAL_CODE_SCHEMA = {
-    "objects": {
-        "<object class>": {
-            "count": {
-                "unit": None,
-                "description": (
-                    "number of instances of this class in the compact spatial code "
-                    "(that schema's per-class oriented-box list length)"
-                ),
-            },
-            "instances": [
-                {
-                    "position": {
-                        "x coordinate": {
-                            "unit": "meters",
-                            "description": (
-                                "x coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                        "y coordinate": {
-                            "unit": "meters",
-                            "description": (
-                                "y coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                        "height above floor": {
-                            "unit": "meters",
-                            "description": (
-                                "height coordinate of this instance's compact 3D oriented "
-                                "bounding box center"
-                            ),
-                        },
-                    },
-                    "longest dimension": {
-                        "unit": "meters",
-                        "description": (
-                            "longest of this instance's compact 3D oriented bounding box "
-                            "dimensions"
-                        ),
-                    },
-                }
-            ],
-        }
-    },
-    "room": {
-        "floor area": {
-            "unit": "square meters",
-            "description": (
-                "shoelace area of the compact spatial code's floor boundary polygons, "
-                "with every interior hole subtracted"
-            ),
-        }
-    },
-    "closest classes distance meters from": {
-        "<object class>": {
-            "<other object class>": {
-                "distance": {
-                    "unit": "meters",
-                    "description": (
-                        "estimated distance in meters between an object of this class "
-                        "and an object of the other class"
-                    ),
-                },
-                "closeness rank": {
-                    "unit": None,
-                    "description": (
-                        "1 = the nearest other class to this one, 2 = second-nearest, "
-                        "and so on; ranked by nearest-instance proximity, so use the "
-                        "rank (not the distance values) to compare which class is "
-                        "closest"
-                    ),
-                },
-            }
-        }
-    },
-    "appearance order": {
-        "unit": None,
-        "description": (
-            "class names ordered by earliest compact 'first visible time' across all of "
-            "that class's instances"
-        ),
-    },
-}
-
-
-def _compact_box_distance(box_a, box_b):
-    """Return the true minimum Euclidean separation of two compact 3D oriented boxes.
-
-    Verbatim derivation from symbolic/adapters.py's oriented_box_distance(): the six box
-    coefficients form one convex bounded least-squares problem, solved exactly by BVLS -- no
-    center, corner, or longest-dimension shortcut, so touching/intersecting boxes return zero.
-
-    Orientation vectors are renormalized to unit length before use, exactly like
-    symbolic/adapters.py's _oriented_box() -- compact's on-disk vectors are rounded to 2
-    decimals, so they are no longer *exactly* unit length, and the matrix below implicitly
-    assumes they are (each column is dimension/2 along that axis). Skipping this step is a
-    real source of error, not just a rounding artifact: it measurably shifted computed
-    distances in testing (up to ~0.01 m on real scenes), and would make explicit silently
-    disagree with what the solver derives from the identical compact box at read time.
-    """
-    from scipy.optimize import lsq_linear
-
-    center_a = np.asarray(
-        box_a["3D oriented bounding box center coordinates"], np.float64
-    )
-    dimensions_a = np.asarray(box_a["3D oriented bounding box dimensions"], np.float64)
-    orientation_a = np.asarray(
-        box_a["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation_a = orientation_a / np.linalg.norm(orientation_a, axis=1, keepdims=True)
-    center_b = np.asarray(
-        box_b["3D oriented bounding box center coordinates"], np.float64
-    )
-    dimensions_b = np.asarray(box_b["3D oriented bounding box dimensions"], np.float64)
-    orientation_b = np.asarray(
-        box_b["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation_b = orientation_b / np.linalg.norm(orientation_b, axis=1, keepdims=True)
-    matrix = np.column_stack(
-        [
-            *(dimensions_a[index] * orientation_a[index] / 2 for index in range(3)),
-            *(-dimensions_b[index] * orientation_b[index] / 2 for index in range(3)),
-        ]
-    )
-    result = lsq_linear(
-        matrix,
-        center_b - center_a,
-        bounds=(-1, 1),
-        method="bvls",
-        lsq_solver="exact",
-        tol=1e-12,
-        max_iter=200,
-    )
-    if not result.success:
-        raise RuntimeError(
-            f"oriented-box distance optimization failed: {result.message}"
-        )
-    distance = float(np.linalg.norm(matrix @ result.x + center_a - center_b))
-    return 0.0 if distance < 1e-10 else distance
-
-
-def _compact_class_distance(instances_a, instances_b):
-    """Return the minimum compact oriented-box distance across every cross-class instance pair."""
-    return min(
-        _compact_box_distance(
-            a["3D oriented bounding box"], b["3D oriented bounding box"]
-        )
-        for a in instances_a
-        for b in instances_b
-    )
-
-
-def _primary_instance_distance_floor(instances_a, instances_b):
-    """A sphere-approximation floor on the two classes' PRIMARY (instance[0]) distance:
-    3D center-to-center distance minus each primary box's longest dimension / 2, floored
-    at 0. Mirrors symbolic/solver.py's _primary_instance_distance_estimate exactly (the
-    same correction, applied at ENCODING time so the table value a reader looks up
-    already carries it -- see _corrected_class_distance below)."""
-    box_a = instances_a[0]["3D oriented bounding box"]
-    box_b = instances_b[0]["3D oriented bounding box"]
-    center_a = box_a["3D oriented bounding box center coordinates"]
-    center_b = box_b["3D oriented bounding box center coordinates"]
-    center_distance = (
-        sum((float(a) - float(b)) ** 2 for a, b in zip(center_a, center_b)) ** 0.5
-    )
-    radius_a = max(box_a["3D oriented bounding box dimensions"]) / 2
-    radius_b = max(box_b["3D oriented bounding box dimensions"]) / 2
-    return max(0.0, center_distance - (radius_a + radius_b))
-
-
-def _corrected_class_distance(instances_a, instances_b):
-    """max(min-across-pairs surface distance, primary-instance sphere floor) -- the
-    combination symbolic/solver.py applies at ANSWER time for ABSOLUTE-distance
-    questions. TRIED AND REVERTED as the table's stored value (2026-07-25, see
-    preregistration.md): baking it in re-derived the closeness RANKS from
-    corrected distances, and closest-of-class ranking is exactly where the raw
-    min-across-instances is the semantically correct quantity -- solver relative-
-    distance accuracy fell 59.2 -> 47.5 on real perceived codes and the VLM pilot
-    dropped in the same direction.
-
-    REINSTATED (2026-07-25, second amendment, see preregistration.md) as the
-    table's PRINTED distance only, with the fix the first attempt lacked: closeness
-    ranks stay computed from the raw min-across-instances distance (the correct
-    closest-of-class quantity), and the solver's relative-distance answer reads the
-    rank field rather than comparing printed values. The printed value IS the solver's
-    absolute-distance answer, making abs-distance a pure lookup for any reader."""
-    return max(
-        _compact_class_distance(instances_a, instances_b),
-        _primary_instance_distance_floor(instances_a, instances_b),
-    )
-
-
-def _compact_polygon_area(coordinates):
-    """Return the unsigned shoelace area of one ordered compact floor-boundary polygon."""
-    if len(coordinates) < 3:
-        return 0.0
-    return abs(
-        sum(
-            coordinates[index][0] * coordinates[(index + 1) % len(coordinates)][1]
-            - coordinates[(index + 1) % len(coordinates)][0] * coordinates[index][1]
-            for index in range(len(coordinates))
-        )
-        / 2
-    )
-
-
-def _compact_room_floor_area(polygons):
-    """Sum outer areas and subtract every interior hole across compact's floor regions."""
-    area = 0.0
-    for polygon in polygons:
-        area += _compact_polygon_area(polygon.get("outer boundary coordinates", []))
-        area -= sum(
-            _compact_polygon_area(hole)
-            for hole in polygon.get("interior hole boundary coordinates", [])
-        )
-    return max(0.0, area)
-
-
-def _compact_box_axis_bounds(box):
-    center = np.asarray(box["3D oriented bounding box center coordinates"], np.float64)
-    dimensions = np.asarray(box["3D oriented bounding box dimensions"], np.float64)
-    orientation = np.asarray(
-        box["3D oriented bounding box orientation unit vectors"], np.float64
-    )
-    orientation = orientation / np.linalg.norm(orientation, axis=1, keepdims=True)
-    offsets = []
-    for sx in (-1.0, 1.0):
-        for sy in (-1.0, 1.0):
-            for sz in (-1.0, 1.0):
-                offsets.append(
-                    sx * dimensions[0] * orientation[0] / 2
-                    + sy * dimensions[1] * orientation[1] / 2
-                    + sz * dimensions[2] * orientation[2] / 2
-                )
-    corners = center + np.asarray(offsets)
-    return [
-        [
-            round(float(corners[:, axis].min()), 2),
-            round(float(corners[:, axis].max()), 2),
-        ]
-        for axis in range(3)
-    ]
-
-
-def _compact_outline_for_v2(compact_code):
-    polygons = compact_code.get("room", {}).get("floor boundary polygons", [])
-    if not polygons:
-        return []
-    outline = []
-    for x, y in polygons[0].get("outer boundary coordinates", []):
-        outline.append(
-            {"floor_x_meters": round(float(x), 1), "floor_y_meters": round(float(y), 1)}
-        )
-    return outline
-
-
-def _explicit_from_compact(compact_code):
-    """Derive a V2 explicit spatial code from an already-built compact spatial code.
-
-    This is used for canonical adapter geometry and ground truth. It mirrors the V2 envelope
-    used by the raw encoder path: no embedded legend, numeric closest-class table, V2 room
-    keys, and compact "appearance order".
-    """
-    compact_objects = compact_code["objects"]
-
-    objects = {}
-    first_visible = {}
-    for class_name, items in compact_objects.items():
-        rendered = []
-        for item in items:
-            box = item["3D oriented bounding box"]
-            center = box["3D oriented bounding box center coordinates"]
-            dimensions = box["3D oriented bounding box dimensions"]
-            bounds = _compact_box_axis_bounds(box)
-            rendered.append(
-                {
-                    "position": {
-                        "floor_x_meters": round(float(center[0]), 2),
-                        "floor_y_meters": round(float(center[1]), 2),
-                        "height_above_floor_meters": round(float(center[2]), 2),
-                    },
-                    "longest_dimension_meters": round(float(max(dimensions)), 2),
-                    "bounding_box": {
-                        "floor_x_meters": bounds[0],
-                        "floor_y_meters": bounds[1],
-                        "height_above_floor_meters": bounds[2],
-                    },
-                    "dimensions_meters": [
-                        round(float(value), 2) for value in dimensions
-                    ],
-                }
-            )
-            time = item["first visible time"]
-            if time is not None:
-                first_visible[class_name] = min(
-                    first_visible.get(class_name, float("inf")), float(time)
-                )
-        objects[class_name] = {"count": len(items), "instances": rendered}
-
-    classes = [name for name, items in compact_objects.items() if items]
-    raw_distances = {class_name: {} for class_name in classes}
-    printed_distances = {class_name: {} for class_name in classes}
-    for index, class_name in enumerate(classes):
-        for other in classes[index + 1 :]:
-            raw = _compact_class_distance(
-                compact_objects[class_name], compact_objects[other]
-            )
-            printed = _corrected_class_distance(
-                compact_objects[class_name], compact_objects[other]
-            )
-            raw_distances[class_name][other] = raw
-            raw_distances[other][class_name] = raw
-            printed_distances[class_name][other] = printed
-            printed_distances[other][class_name] = printed
-    closest = {}
-    for class_name, distances in raw_distances.items():
-        ranked = sorted(distances.items(), key=lambda item: (item[1], item[0]))
-        closest[class_name] = {
-            other: {
-                "closeness_rank": rank + 1,
-                "distance_meters": round(printed_distances[class_name][other], 2),
-            }
-            for rank, (other, _raw) in enumerate(ranked)
-        }
-
-    floor_area = round(
-        _compact_room_floor_area(
-            compact_code["room"].get("floor boundary polygons", [])
-        ),
-        1,
-    )
-
-    return {
-        "objects": objects,
-        "room": {
-            "outline": _compact_outline_for_v2(compact_code),
-            "floor_area_square_meters": floor_area,
-        },
-        "closest_classes_from": closest,
-        "appearance order": sorted(
-            classes, key=lambda name: first_visible.get(name, float("inf"))
-        ),
-    }, floor_area
-
-
-def _build_reference_v2_spatial_code(raw_inputs):
-    """Build the raw encoder spatial code exactly like the reference V2 branch."""
-    alias = {"coat hanger": "coat rack"}
-    per = {
-        alias.get(class_name, class_name): frames
-        for class_name, frames in raw_inputs["per"].items()
-    }
-    depth = raw_inputs["depth"]
-    intr = raw_inputs["intr"]
-    c2w = raw_inputs["c2w"]
-    conf = raw_inputs.get("conf")
-    frame_times = raw_inputs["ftimes"]
-
-    up_vec, up_axis = room_gravity(depth, intr, c2w, conf)
-    instances, stats = build_instances(
-        per, depth, intr, c2w, conf, frame_times, up_axis=up_axis
-    )
-    u, v, g = _floor_basis(up_vec)
-    all_points = np.concatenate(
-        [item["pts"] for values in instances.values() for item in values], axis=0
-    )
-    floor_level = float(np.percentile(all_points @ g, 2))
-    floor_area = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
-    code = _reference_to_spatial_code(
-        instances, stats, floor_area, up_axis, up_vec, floor_level
-    )
-    classes = list(instances.keys())
-    class_first = {
-        class_name: min(item["first_time"] for item in values)
-        for class_name, values in instances.items()
-    }
-
-    for class_name in classes:
-        ranked = sorted(
-            instances[class_name],
-            key=lambda item: (item["n"], item.get("nframes", 0)),
-            reverse=True,
-        )
-        for record, item in zip(code["objects"][class_name]["instances"], ranked):
-            record["seen_in_video_frames"] = int(
-                item.get("nframes", len(item.get("frames", ())))
-            )
-
-    closest = {}
-    for class_name in classes:
-        distances = sorted(
-            (
-                round(
-                    answer_closest_distance(instances[class_name], instances[other]), 2
-                ),
-                other,
-            )
-            for other in classes
-            if other != class_name
-        )
-        closest[class_name] = {
-            other: {"closeness_rank": rank + 1, "distance_meters": distance}
-            for rank, (distance, other) in enumerate(distances)
-        }
-    code["closest_classes_from"] = closest
-
-    waypoints = []
-    next_time = 0.0
-    for index, time_seconds in enumerate(np.asarray(frame_times, np.float64)):
-        if time_seconds + 1e-9 < next_time:
-            continue
-        next_time = float(time_seconds) + 5.0
-        position = c2w[index][:3, 3]
-        forward = c2w[index][:3, 2]
-        waypoints.append(
-            {
-                "time_seconds": round(float(time_seconds), 1),
-                "floor_x_meters": round(float(position @ u), 2),
-                "floor_y_meters": round(float(position @ v), 2),
-                "heading_degrees": round(
-                    float(np.degrees(np.arctan2(forward @ v, forward @ u)))
-                ),
-            }
-        )
-    code["camera_trajectory"] = {
-        "sample_interval_seconds": 5,
-        "waypoints": waypoints,
-    }
-    code["room"] = {
-        "outline": _room_outline(depth, intr, c2w, conf, u, v),
-        "floor_area_square_meters": code["room"]["floor_area_square_meters"],
-    }
-    code["appearance order"] = [
-        class_name
-        for class_name, _time in sorted(class_first.items(), key=lambda item: item[1])
-    ]
-    return code, instances, stats, up_axis, up_vec, floor_area
-
-
-def build_explicit_spatial_code(scene):
-    """Build the selected explicit code.
-
-    Raw encoder inputs follow the original geometric V2 spatial-code construction. Canonical
-    geometry keeps the compact-derived schema used by ground-truth and non-raw adapters.
-    """
-    raw_inputs = scene.get("raw_inputs")
-    if raw_inputs is not None:
-        return _build_reference_v2_spatial_code(raw_inputs)
-
-    compact_code, instances, stats, up_ax, up_vec, _ = build_compact_spatial_code(scene)
-    code, floor_area = _explicit_from_compact(compact_code)
-    return code, instances, stats, up_ax, up_vec, floor_area
-
-
-# ==========================================================================================
-# MODEL-AGNOSTIC ENTRY POINT
-# ==========================================================================================
-
-
-def build_spatial_code(scene, spatial_code_format="explicit"):
-    """Build one selected spatial-code schema from canonical scene geometry.
-
-    Compact is built directly from raw depth/pose/mask bundles or canonical world-space
-    geometry (build_compact_spatial_code() handles that duality). Explicit is always a
-    derivation of compact (build_explicit_spatial_code() calls build_compact_spatial_code()
-    first), so there is no separate raw/canonical branch for explicit any more.
-    """
-    if spatial_code_format == "compact":
-        return build_compact_spatial_code(scene)
-    if spatial_code_format != "explicit":
-        raise ValueError(f"unknown spatial-code format {spatial_code_format!r}")
-    return build_explicit_spatial_code(scene)

encoder/ground_truth.py

@@ -1,280 +0,0 @@
-"""Ground-truth spatial codes: the same compact/explicit schemas encoder/geometric.py
-produces from the perception pipeline (SAM3 + Depth Anything 3), but built directly from
-the dataset's own annotated 3D object boxes and room size instead -- perfect geometry,
-zero perception error, for isolating "does the VLM's spatial reasoning improve when the
-input geometry is exactly right" from "is the encoder's perception good enough."
-
-Sourced from thinking-in-space's meta_info (the same ground truth thinking-in-space's own
-official VSI-Bench scorer trains/evaluates against): per-scene `object_bbox` (each
-instance's centroid/axesLengths/normalizedAxes -- a full 3D oriented box) and `room_size`
-(the room's true floor area). Two things meta_info does NOT carry, because they are
-properties of a specific camera walkthrough rather than of the scene's static geometry:
-
-- Room SHAPE (only the scalar area is annotated): represented as a single axis-aligned
-  square floor polygon of exactly that area, centered at the scene's own `room_center` --
-  the honest floor-shape representation the data supports, matching real area exactly
-  under the same shoelace derivation compact/explicit already use, without inventing a
-  boundary the annotations don't contain.
-- Per-object "first visible time" (when a class first appears on camera -- inherently a
-  property of the video, not the 3D scan): there is no such ground truth for the average
-  object, but VSI-Bench's own `obj_appearance_order` questions DO carry genuine human
-  ground truth ordering for the specific classes they ask about. Every appearance-order
-  question for a scene contributes a same-scene ordering constraint (see
-  _appearance_order_ranks); classes never covered by any such question for that scene
-  get "first visible time": null (no fabricated number) and sort after every timed class
-  in "appearance order".
-
-Coordinate convention: thinking-in-space's meta_info coordinates are already gravity-
-aligned per-scene (z is up; verified empirically -- `room_center` z is tightly clustered
-near a small non-negative range across every scannet scene, unlike x/y, and ARKitScenes'
-axis-locked object boxes carry an exact [0, 0, 1] orientation row), so -- unlike the real
-encoder pipeline, which must estimate gravity from a noisy reconstructed point cloud --
-ground truth's own x, y, z pass straight through as the compact schema's own (x, y,
-height above floor) room frame; only a floor reference (z of the annotations' own lowest
-point) needs to be established.
-"""
-
-from __future__ import annotations
-
-import json
-from functools import lru_cache
-from pathlib import Path
-
-import numpy as np
-
-from encoder import config
-from encoder.geometric import (
-    COMPACT_SPATIAL_CODE_SCHEMA,
-    _compact_room_floor_area,
-    _explicit_from_compact,
-    _rounded_list,
-    dump_spatial_code,
-)
-
-META_INFO_DIR = Path(config.DATA_ROOT) / "thinking-in-space" / "data" / "meta_info"
-META_INFO_DATASETS = ("scannet", "arkitscenes", "scannetpp")
-
-
-@lru_cache(maxsize=1)
-def load_meta_info():
-    """Return {scene: record} merged across every dataset's meta_info file, each record
-    carrying its own "dataset" key (scannet / arkitscenes / scannetpp)."""
-    merged = {}
-    for dataset in META_INFO_DATASETS:
-        path = META_INFO_DIR / f"{dataset}_meta_info_val.json"
-        with open(path, encoding="utf-8") as stream:
-            records = json.load(stream)
-        for scene, record in records.items():
-            merged[str(scene)] = {**record, "dataset": dataset}
-    return merged
-
-
-@lru_cache(maxsize=1)
-def _appearance_order_ranks_by_scene():
-    """Return {scene: {class_name: rank}} decoded from every real
-    ``obj_appearance_order`` question's ground_truth answer in test.jsonl -- a DAG of
-    "class X appears no later than class Y" edges per scene, topologically ranked (DFS,
-    back-edges from any inconsistent question ignored rather than raising, since a rank
-    is still useful even if two annotators' four-item orderings can't be perfectly
-    reconciled). Classes never named by any appearance-order question for that scene are
-    simply absent from the returned mapping.
-    """
-    edges_by_scene = {}
-    with open(config.JSONL, encoding="utf-8") as stream:
-        for line in stream:
-            question = json.loads(line)
-            if question.get("question_type") != "obj_appearance_order":
-                continue
-            scene = str(question["scene_name"])
-            index = ord(question["ground_truth"]) - ord("A")
-            option = question["options"][index]
-            classes = [name.strip() for name in option.split(".", 1)[1].split(",")]
-            edges = edges_by_scene.setdefault(scene, {})
-            for earlier, later in zip(classes, classes[1:]):
-                edges.setdefault(earlier, set()).add(later)
-
-    ranks_by_scene = {}
-    for scene, edges in edges_by_scene.items():
-        nodes = set(edges) | {
-            node for successors in edges.values() for node in successors
-        }
-        order = []
-        visited, in_progress = set(), set()
-
-        def visit(node):
-            if node in visited or node in in_progress:
-                return
-            in_progress.add(node)
-            for successor in sorted(edges.get(node, ())):
-                visit(successor)
-            in_progress.discard(node)
-            visited.add(node)
-            order.append(node)
-
-        for node in sorted(nodes):
-            visit(node)
-        order.reverse()
-        ranks_by_scene[scene] = {name: rank for rank, name in enumerate(order)}
-    return ranks_by_scene
-
-
-def _floor_level(object_bbox):
-    """Return the lowest z any annotated object's oriented box reaches: the support of
-    each box along -z, i.e. centroid_z minus the box's half-extent projected onto z
-    (sum of half-dimension * |axis . z| across all three axes -- the true lowest corner
-    of a tilted box, not just its centroid)."""
-    lowest = []
-    for instances in object_bbox.values():
-        for instance in instances:
-            centroid_z = float(instance["centroid"][2])
-            dims = np.asarray(instance["axesLengths"], np.float64)
-            axes = np.asarray(instance["normalizedAxes"], np.float64).reshape(3, 3)
-            axes = axes / np.linalg.norm(axes, axis=1, keepdims=True)
-            half_extent_z = float(np.sum(dims / 2 * np.abs(axes[:, 2])))
-            lowest.append(centroid_z - half_extent_z)
-    return min(lowest) if lowest else 0.0
-
-
-def _gt_oriented_box(instance, floor_level):
-    """Return one compact "3D oriented bounding box" dict straight from a meta_info
-    object_bbox instance -- centroid/axesLengths/normalizedAxes pass through as this
-    dataset's own gravity-aligned x, y, z (see module docstring), only re-based so the
-    third component is height above this scene's own floor reference."""
-    centroid = np.asarray(instance["centroid"], np.float64)
-    dims = np.asarray(instance["axesLengths"], np.float64)
-    axes = np.asarray(instance["normalizedAxes"], np.float64).reshape(3, 3)
-    axes = axes / np.linalg.norm(axes, axis=1, keepdims=True)
-    center = [float(centroid[0]), float(centroid[1]), float(centroid[2]) - floor_level]
-    return {
-        "3D oriented bounding box center coordinates": _rounded_list(center),
-        "3D oriented bounding box dimensions": _rounded_list(dims.tolist()),
-        "3D oriented bounding box orientation unit vectors": [
-            _rounded_list(row.tolist()) for row in axes
-        ],
-    }
-
-
-def _gt_floor_boundary_polygons(room_size, room_center):
-    """A single axis-aligned square of exactly area ``room_size`` centered at
-    ``room_center``'s (x, y) -- the floor-SHAPE stand-in the annotations actually
-    support (see module docstring); no holes, since meta_info carries no boundary
-    detail to place one from."""
-    half_side = float(np.sqrt(max(room_size, 0.0))) / 2
-    cx, cy = float(room_center[0]), float(room_center[1])
-    corners = [
-        [cx - half_side, cy - half_side],
-        [cx + half_side, cy - half_side],
-        [cx + half_side, cy + half_side],
-        [cx - half_side, cy + half_side],
-    ]
-    return [
-        {
-            "outer boundary coordinates": [_rounded_list(corner) for corner in corners],
-            "interior hole boundary coordinates": [],
-        }
-    ]
-
-
-def build_compact_ground_truth_spatial_code(scene):
-    """Build the compact spatial code for ``scene`` directly from its dataset annotation
-    (meta_info), in the exact COMPACT_SPATIAL_CODE_SCHEMA shape/legend build_compact_
-    spatial_code() produces from the perception pipeline."""
-    meta = load_meta_info()
-    if scene not in meta:
-        raise KeyError(f"no meta_info ground truth for scene {scene!r}")
-    record = meta[scene]
-    object_bbox = record["object_bbox"]
-    floor_level = _floor_level(object_bbox)
-    ranks = _appearance_order_ranks_by_scene().get(scene, {})
-
-    objects = {}
-    for class_name, instances in object_bbox.items():
-        rank = ranks.get(class_name)
-        objects[class_name] = [
-            {
-                "3D oriented bounding box": _gt_oriented_box(instance, floor_level),
-                "first visible time": float(rank) if rank is not None else None,
-            }
-            for instance in instances
-        ]
-
-    return {
-        "objects": objects,
-        "room": {
-            "floor boundary polygons": _gt_floor_boundary_polygons(
-                record["room_size"], record["room_center"]
-            )
-        },
-    }
-
-
-def build_explicit_ground_truth_spatial_code(scene):
-    """Build the explicit spatial code for ``scene`` as the exact same strict derivation
-    of a compact code that build_explicit_spatial_code() uses for encoder-built codes,
-    applied to build_compact_ground_truth_spatial_code()'s output instead."""
-    compact_code = build_compact_ground_truth_spatial_code(scene)
-    code, _floor_area = _explicit_from_compact(compact_code)
-    return code
-
-
-def build_ground_truth_spatial_code(scene, spatial_code_format="explicit"):
-    """Dispatch to the compact or explicit ground-truth builder, mirroring
-    encoder.geometric.build_spatial_code's format switch."""
-    if spatial_code_format == "compact":
-        return build_compact_ground_truth_spatial_code(scene)
-    if spatial_code_format == "explicit":
-        return build_explicit_ground_truth_spatial_code(scene)
-    raise ValueError(
-        f"unknown spatial-code format {spatial_code_format!r}; expected 'compact' or 'explicit'"
-    )
-
-
-def build_and_write(scene, spatial_code_format="explicit"):
-    """Build one scene's ground-truth spatial code and write it to its on-disk path
-    (encoder.config.ground_truth_spatial_code_path), creating parent directories as
-    needed. Returns the path written."""
-    code = build_ground_truth_spatial_code(scene, spatial_code_format)
-    path = config.ground_truth_spatial_code_path(scene, spatial_code_format)
-    Path(path).parent.mkdir(parents=True, exist_ok=True)
-    dump_spatial_code(code, path)
-    return path
-
-
-def scenes():
-    """Every scene meta_info has ground truth for (a superset of every scene any
-    perception-built spatial code could ever cover, since this needs no SAM3/DA3 cache).
-    """
-    return sorted(load_meta_info())
-
-
-def build_all(spatial_code_formats=("explicit", "compact"), scene_list=None):
-    """Build and write ground-truth spatial codes for every scene (or ``scene_list``)
-    in both formats by default. Returns the list of paths written."""
-    written = []
-    for scene in scene_list if scene_list is not None else scenes():
-        for spatial_code_format in spatial_code_formats:
-            written.append(build_and_write(scene, spatial_code_format))
-    return written
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--scenes", help="comma-separated scenes (default: every scene)"
-    )
-    parser.add_argument(
-        "--formats",
-        default="explicit,compact",
-        help="comma-separated spatial-code formats",
-    )
-    args = parser.parse_args()
-    scene_list = (
-        [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if args.scenes
-        else None
-    )
-    formats = tuple(fmt.strip() for fmt in args.formats.split(",") if fmt.strip())
-    paths = build_all(formats, scene_list)
-    print(f"wrote {len(paths)} ground-truth spatial codes")

encoder/launch.py

@@ -1,301 +0,0 @@
-"""Persistent CPU-parallel batch driver for the VSI encoder.
-
-Without a scene argument, processes manifest scenes with all required inference caches.
-CPU-bound encoding defaults to one worker per available CPU, with nested numerical
-threads budgeted across workers.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import multiprocessing as mp
-import os
-from pathlib import Path
-import subprocess
-import sys
-import traceback
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from encoder import config  # noqa: E402
-
-
-def _scenes():
-    with open(config.JSONL) as f:
-        return list(dict.fromkeys(str(json.loads(line)["scene_name"]) for line in f))
-
-
-def _video_cache_files(scene, depth, tracking):
-    """Return full-video perception-cache files for the selected axes."""
-    return (
-        Path(config.video_da3_cache_file(scene, depth)),
-        Path(config.video_sam3_cache_file(scene, tracking)),
-    )
-
-
-def _has_required_caches(
-    scene, depth, input_selection, tracking, frame_count, video=False
-):
-    """Return whether all inference caches needed for encoding exist."""
-    if video:
-        paths = _video_cache_files(scene, depth, tracking)
-    else:
-        paths = (
-            config.sam3_cache_file(scene, input_selection, tracking, frame_count),
-            config.da3_cache_file(scene, depth, input_selection, frame_count),
-        )
-    return all(os.path.isfile(path) for path in paths)
-
-
-def _scenes_with_required_caches(
-    depth, input_selection, tracking, frame_count, video=False
-):
-    """Return manifest scenes having every cache required by this encoder run."""
-    return [
-        scene
-        for scene in _scenes()
-        if _has_required_caches(
-            scene, depth, input_selection, tracking, frame_count, video
-        )
-    ]
-
-
-def _available_cpu_count():
-    """Return the CPUs available to this process, respecting affinity and overrides."""
-    configured = os.environ.get("VSI_CPU_WORKERS")
-    if configured is not None:
-        count = int(configured)
-        if count < 1:
-            raise ValueError("VSI_CPU_WORKERS must be positive")
-        return count
-    try:
-        return max(1, len(os.sched_getaffinity(0)))
-    except AttributeError:
-        return max(1, os.cpu_count() or 1)
-
-
-def _visible_gpus():
-    configured = os.environ.get("CUDA_VISIBLE_DEVICES")
-    if configured is not None:
-        return [
-            x.strip() for x in configured.split(",") if x.strip() and x.strip() != "-1"
-        ]
-    try:
-        out = subprocess.check_output(
-            ["nvidia-smi", "--query-gpu=index", "--format=csv,noheader"],
-            text=True,
-            stderr=subprocess.DEVNULL,
-        )
-        return [line.strip() for line in out.splitlines() if line.strip()]
-    except (FileNotFoundError, subprocess.SubprocessError):
-        return []
-
-
-def _worker(
-    task_queue,
-    result_queue,
-    depth,
-    input_selection,
-    tracking,
-    frame_count,
-    rebuild,
-    cpu_threads,
-    video,
-):
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    import cv2
-
-    cv2.setNumThreads(cpu_threads)
-    os.environ["VSI_KD_WORKERS"] = str(cpu_threads)
-    # torch ignores the OMP/MKL/OPENBLAS env vars above (and sched_getaffinity/cgroup
-    # limits) -- it defaults both its intra-op and inter-op pools to the machine's full
-    # logical core count. adapters._load_native_sam3 imports torch to read the SAM3
-    # cache, so every worker would otherwise spin up its own full-width thread pool on
-    # top of the budget already enforced for numpy/cv2/scipy.
-    import torch
-
-    torch.set_num_threads(cpu_threads)
-    try:
-        torch.set_num_interop_threads(cpu_threads)
-    except RuntimeError:
-        pass  # already used/set once in this process; not worth failing the worker over
-    from encoder import render
-    from encoder.adapters import EmptySceneError
-
-    while True:
-        scene = task_queue.get()
-        if scene is None:
-            return
-        try:
-            _, how, path = render.write_spatial_code_for(
-                scene,
-                depth,
-                input_selection,
-                tracking,
-                frame_count,
-                rebuild,
-                video,
-            )
-            result_queue.put((scene, "done", f"{how} -> {path}"))
-        except EmptySceneError:
-            result_queue.put((scene, "skipped", "cache produced no instances"))
-        except Exception:
-            result_queue.put((scene, "failed", traceback.format_exc()))
-
-
-def _launch(args, selected):
-    label = (
-        f"{args.depth}/{args.tracking}/video"
-        if args.video
-        else f"{args.depth}/{args.tracking}/{args.input_selection}/{args.frames}"
-    )
-    pending = []
-    completed = 0
-    for scene in selected:
-        output_exists = os.path.exists(
-            config.spatial_code_path(
-                scene,
-                args.depth,
-                args.input_selection,
-                args.tracking,
-                args.frame_count,
-                "explicit",
-            )
-        )
-        if output_exists and not args.rebuild:
-            completed += 1
-            print(f"[{label} {completed}/{len(selected)}] {scene}: skipped", flush=True)
-        else:
-            pending.append(scene)
-    if not pending:
-        print(f"[{label}] DONE: {len(selected)} ok, 0 failed")
-        return
-
-    cpu_count = _available_cpu_count()
-    worker_count = args.workers or cpu_count
-    if worker_count < 1:
-        raise ValueError("--workers must be positive or zero for automatic")
-    worker_count = min(worker_count, len(pending))
-    cpu_threads = max(1, cpu_count // worker_count)
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    print(
-        f"[{label}] starting {worker_count} persistent CPU worker(s); "
-        f"threads per worker={cpu_threads}",
-        flush=True,
-    )
-
-    context = mp.get_context("spawn")
-    tasks, results = context.Queue(), context.Queue()
-    for scene in pending:
-        tasks.put(scene)
-    for _ in range(worker_count):
-        tasks.put(None)
-    processes = [
-        context.Process(
-            target=_worker,
-            args=(
-                tasks,
-                results,
-                args.depth,
-                args.input_selection,
-                args.tracking,
-                args.frame_count,
-                args.rebuild,
-                cpu_threads,
-                args.video,
-            ),
-        )
-        for _ in range(worker_count)
-    ]
-    for process in processes:
-        process.start()
-
-    failed = []
-    skipped = 0
-    for _ in pending:
-        scene, status, detail = results.get()
-        completed += 1
-        if status == "failed":
-            failed.append(scene)
-        elif status == "skipped":
-            skipped += 1
-        display_status = "FAILED" if status == "failed" else status
-        print(
-            f"[{label} {completed}/{len(selected)}] {scene}: "
-            f"{display_status}\n{detail}",
-            flush=True,
-        )
-    for process in processes:
-        process.join()
-    succeeded = len(selected) - len(failed) - skipped
-    print(
-        f"[{label}] DONE: {succeeded} ok, {skipped} skipped, " f"{len(failed)} failed"
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument("--depth", choices=config.DEPTH_VARIANTS)
-    parser.add_argument(
-        "--input",
-        choices=config.INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument(
-        "--video",
-        action="store_true",
-        help="use full-video DA3 and SAM3 caches",
-    )
-    parser.add_argument("--tracking", choices=config.TRACKING_MODES)
-    parser.add_argument(
-        "--workers",
-        type=int,
-        default=0,
-        help="persistent workers (default: all available CPUs)",
-    )
-    parser.add_argument("--rebuild", action="store_true")
-    args = parser.parse_args()
-    if args.depth is None:
-        parser.error("--depth is required")
-    if args.tracking is None:
-        parser.error("--tracking is required")
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input cannot be used with --video")
-        args.input_selection = config.VIDEO_INPUT_SELECTION
-    elif args.input_selection is None:
-        parser.error("--input is required with --frames")
-    if args.frames is not None and args.frames < 1:
-        parser.error("--frames must be positive")
-    args.frame_count = args.frames
-    if args.workers < 0:
-        parser.error("--workers must be positive or zero for automatic")
-    selected = (
-        [args.scene]
-        if args.scene
-        else _scenes_with_required_caches(
-            args.depth,
-            args.input_selection,
-            args.tracking,
-            args.frame_count,
-            args.video,
-        )
-    )
-    if not selected:
-        print("DONE: no manifest scenes have all required caches")
-        return
-    _launch(args, selected)
-
-
-if __name__ == "__main__":
-    main()

encoder/render.py

@@ -1,73 +0,0 @@
-"""Build and write one final spatial-code JSON file per scene."""
-
-from __future__ import annotations
-
-import os
-
-from encoder import config
-from encoder import geometric as geometry_math
-from encoder import run as perceive
-
-
-def build_spatial_code_for(
-    scene,
-    depth,
-    input_selection,
-    tracking,
-    frame_count=config.FRAMES_PER_VIDEO,
-    rebuild=False,
-    video=False,
-    da3_path=None,
-    sam3_path=None,
-):
-    """Build a spatial code from cached or newly adapted scene geometry."""
-    if video:
-        input_selection = config.VIDEO_INPUT_SELECTION
-    kwargs = {"video": video}
-    if da3_path is not None:
-        kwargs["da3_path"] = da3_path
-    if sam3_path is not None:
-        kwargs["sam3_path"] = sam3_path
-    geometry, how = perceive.cache_or_load(
-        scene, depth, input_selection, tracking, frame_count, rebuild, **kwargs
-    )
-    code, *_ = geometry_math.build_spatial_code(geometry, "explicit")
-    return code, how
-
-
-def write_spatial_code_for(
-    scene,
-    depth,
-    input_selection,
-    tracking,
-    frame_count=config.FRAMES_PER_VIDEO,
-    rebuild=False,
-    video=False,
-    da3_path=None,
-    sam3_path=None,
-):
-    """Build and write one scene's spatial-code JSON."""
-    if video:
-        input_selection = config.VIDEO_INPUT_SELECTION
-    code, how = build_spatial_code_for(
-        scene,
-        depth,
-        input_selection,
-        tracking,
-        frame_count,
-        rebuild,
-        video,
-        da3_path,
-        sam3_path,
-    )
-    path = config.spatial_code_path(
-        scene,
-        depth,
-        input_selection,
-        tracking,
-        frame_count,
-        "explicit",
-    )
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    geometry_math.dump_spatial_code(code, path)
-    return code, how, path

encoder/run.py

@@ -1,276 +0,0 @@
-"""Load or build one flat per-scene cache file for the selected model."""
-
-from __future__ import annotations
-
-import argparse
-import gzip
-import hashlib
-import os
-from pathlib import Path
-import pickle
-import sys
-
-# Single-scene CLI runs (unlike launch.py's budgeted batch workers) otherwise inherit
-# whatever thread defaults numpy/BLAS/scipy pick -- typically "use every core" -- which
-# thrashes when geometric.py makes many small parallel-dispatched calls (cv2 ops per
-# mask, KD-tree queries per class pair). setdefault() so launch.py's explicit
-# per-worker budget (set before it imports this module via render.py) always wins.
-for _var in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-    os.environ.setdefault(_var, "1")
-os.environ.setdefault("VSI_KD_WORKERS", "1")
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from encoder import adapters  # noqa: E402
-from encoder import config  # noqa: E402
-
-PROVENANCE_KEY = "source_provenance"
-PROVENANCE_VERSION = 1
-
-
-def _source_record(path):
-    """Describe one native cache without copying its payload."""
-    source = Path(path)
-    size = source.stat().st_size
-    digest = hashlib.sha256()
-    with source.open("rb") as stream:
-        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return {"path": str(source), "size": size, "sha256": digest.hexdigest()}
-
-
-def _source_provenance(scene, mode, paths):
-    """Record the exact native caches used to derive a combined cache."""
-    return {
-        "format_version": PROVENANCE_VERSION,
-        "scene": scene,
-        "mode": mode,
-        "sources": {name: _source_record(path) for name, path in paths.items()},
-    }
-
-
-def _verify_source_provenance(provenance):
-    """Ensure every referenced native cache still matches byte-for-byte."""
-    if (
-        not isinstance(provenance, dict)
-        or provenance.get("format_version") != PROVENANCE_VERSION
-    ):
-        raise ValueError("combined cache has unsupported source provenance")
-    sources = provenance.get("sources")
-    if not isinstance(sources, dict) or set(sources) != {"sam3", "depth-anything-3"}:
-        raise ValueError("combined cache source provenance is incomplete")
-    for name, expected in sources.items():
-        if not isinstance(expected, dict) or "path" not in expected:
-            raise ValueError(f"combined cache source {name!r} has invalid provenance")
-        try:
-            actual = _source_record(expected["path"])
-        except FileNotFoundError as exc:
-            raise FileNotFoundError(
-                f"combined cache source {name!r} is missing: {expected['path']}"
-            ) from exc
-        if actual["size"] != expected.get("size") or actual["sha256"] != expected.get(
-            "sha256"
-        ):
-            raise ValueError(
-                f"combined cache source {name!r} no longer matches its provenance"
-            )
-
-
-def _video_cache_files(scene, depth, tracking):
-    """Return the full-video DA3 + SAM3 cache pair for the selected axes."""
-    return (
-        config.video_da3_cache_file(scene, depth),
-        config.video_sam3_cache_file(scene, tracking),
-    )
-
-
-def _effective_dimensions(depth, input_selection, tracking, video):
-    """Map video input onto its path branch without changing other axes."""
-    if video:
-        return depth, config.VIDEO_INPUT_SELECTION, tracking
-    return depth, input_selection, tracking
-
-
-def _cache_source_paths(
-    scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
-):
-    """Resolve the selected DA3/SAM3 source pair without changing adapter semantics."""
-    if video:
-        default_da3, default_sam3 = _video_cache_files(scene, depth, tracking)
-    else:
-        default_da3 = config.da3_cache_file(scene, depth, input_selection, frame_count)
-        default_sam3 = config.sam3_cache_file(
-            scene, input_selection, tracking, frame_count
-        )
-    return da3_path or default_da3, sam3_path or default_sam3
-
-
-def _combined_cache_file(
-    scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
-):
-    """Return a combined-cache path isolated by source cache format and explicit paths."""
-    if da3_path is None and sam3_path is None:
-        return config.cache_file(scene, depth, input_selection, tracking, frame_count)
-    label = config.VIDEO_INPUT_SELECTION if video else "custom"
-    if da3_path is not None or sam3_path is not None:
-        digest = hashlib.sha256()
-        digest.update(str(da3_path or "").encode())
-        digest.update(b"\0")
-        digest.update(str(sam3_path or "").encode())
-        label = f"{label}-{digest.hexdigest()[:12]}"
-    directory = config.CACHE_ROOT / config.MODEL / depth / tracking / label
-    if not video:
-        directory = directory / str(frame_count)
-    return str(directory / f"{scene}.pkl.gz")
-
-
-def cache_or_load(
-    scene,
-    depth,
-    input_selection,
-    tracking,
-    frame_count=config.FRAMES_PER_VIDEO,
-    rebuild=False,
-    video=False,
-    da3_path=None,
-    sam3_path=None,
-):
-    """Return canonical geometry for one specific set of input dimensions."""
-    depth, input_selection, tracking = _effective_dimensions(
-        depth, input_selection, tracking, video
-    )
-    path = _combined_cache_file(
-        scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
-    )
-    if os.path.exists(path) and not rebuild:
-        with gzip.open(path, "rb") as stream:
-            cached = pickle.load(stream)
-        provenance = cached.get(PROVENANCE_KEY) if isinstance(cached, dict) else None
-        if provenance is not None:
-            _verify_source_provenance(provenance)
-            return adapters.validate(cached), "loaded"
-        # Legacy combined caches are rebuilt to attach exact source provenance.
-
-    selected_da3_path, selected_sam3_path = _cache_source_paths(
-        scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
-    )
-    raw_cache = {
-        "scene": scene,
-        "root": str(config.CACHE_ROOT),
-        "rebuild": rebuild,
-        "da3_path": selected_da3_path,
-        "sam3_path": selected_sam3_path,
-    }
-    geometry = adapters.adapt(config.MODEL, **raw_cache)
-    mode = f"{input_selection}:{frame_count}:{tracking}"
-    geometry[PROVENANCE_KEY] = _source_provenance(
-        scene,
-        mode,
-        {
-            "sam3": raw_cache["sam3_path"],
-            "depth-anything-3": raw_cache["da3_path"],
-        },
-    )
-    geometry[PROVENANCE_KEY].update(
-        {
-            "depth": depth,
-            "input": input_selection,
-            "tracking": tracking,
-            "frames": frame_count,
-            "video": bool(video),
-        }
-    )
-    _verify_source_provenance(geometry[PROVENANCE_KEY])
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with gzip.open(path, "wb") as stream:
-        pickle.dump(geometry, stream, protocol=pickle.HIGHEST_PROTOCOL)
-    return geometry, "built"
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene")
-    parser.add_argument("--depth", choices=config.DEPTH_VARIANTS)
-    parser.add_argument(
-        "--input",
-        choices=config.INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument(
-        "--video",
-        action="store_true",
-        help="use full-video DA3 and SAM3 caches",
-    )
-    parser.add_argument("--tracking", choices=config.TRACKING_MODES)
-    parser.add_argument(
-        "--da3-path", default=None, help="override the selected DA3 cache path"
-    )
-    parser.add_argument(
-        "--sam3-path", default=None, help="override the selected SAM3 cache path"
-    )
-    parser.add_argument("--rebuild", action="store_true")
-    args = parser.parse_args()
-    if args.depth is None:
-        parser.error("--depth is required")
-    if args.tracking is None:
-        parser.error("--tracking is required")
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input cannot be used with --video")
-        args.input_selection = config.VIDEO_INPUT_SELECTION
-    elif args.input_selection is None:
-        parser.error("--input is required with --frames")
-    if args.frames is not None and args.frames < 1:
-        parser.error("--frames must be positive")
-    frame_count = args.frames
-    from encoder import render
-
-    import cv2
-
-    cv2.setNumThreads(1)  # see thread-budget note near the top imports
-
-    import torch  # torch ignores the OMP/MKL/OPENBLAS env vars set above
-
-    torch.set_num_threads(1)
-    try:
-        torch.set_num_interop_threads(1)
-    except RuntimeError:
-        pass
-
-    geometry, how = cache_or_load(
-        args.scene,
-        args.depth,
-        args.input_selection,
-        args.tracking,
-        frame_count,
-        args.rebuild,
-        args.video,
-        args.da3_path,
-        args.sam3_path,
-    )
-    count = sum(len(values) for values in geometry["instances"].values())
-    print(
-        f"[{args.scene}] depth={args.depth} input={args.input_selection} "
-        f"frames={args.frames} tracking={args.tracking} video={args.video} cache={how} "
-        f"classes={len(geometry['instances'])} instances={count}"
-    )
-    _, _, path = render.write_spatial_code_for(
-        args.scene,
-        args.depth,
-        args.input_selection,
-        args.tracking,
-        frame_count,
-        False,
-        args.video,
-        args.da3_path,
-        args.sam3_path,
-    )
-    print(f"[{args.scene}] spatial_code={path}")
-
-
-if __name__ == "__main__":
-    main()