Update modular inference, encoder, tests, and cache layout (part 2)

encoder/adapters.py

@@ -20,6 +20,14 @@ import sys
 import numpy as np
 
 
+RAW_CACHE_ROOT = "/root/data/caches"
+
+
+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)
+
+
 # ==========================================================================================
 # CANONICAL SHAPE -- validation only. Plain dicts on purpose: no schema/contract class layer.
 # ==========================================================================================
@@ -114,7 +122,11 @@ def _load_native_sam3(path):
             masks = response["outputs"].get("masks")
         if masks is None:
             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)
+        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:
@@ -150,7 +162,9 @@ def _load_native_da3(path):
     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 = 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):
@@ -161,24 +175,29 @@ def _load_native_da3(path):
     return depth, intr, c2w, conf
 
 
-def _backproject(depth, K, c2w, mask, conf=None):
+def _backproject(depth, intrinsics, c2w, mask, conf=None):
     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
-    Xc = np.stack([(xs - K[0, 2]) * z / K[0, 0], (ys - K[1, 2]) * z / K[1, 1], z], 1)
-    Xw = (c2w[:3, :3] @ Xc.T).T + c2w[:3, 3]
+    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 Xw.astype(np.float32), cf
+    return world_points.astype(np.float32), cf
 
 
-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."""
-    if root and scene:
+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:
@@ -187,6 +206,10 @@ def adapt_sam3_depth_anything_3(
         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)
@@ -194,8 +217,20 @@ def adapt_sam3_depth_anything_3(
         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)
+        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 = {}
@@ -217,7 +252,7 @@ def adapt_sam3_depth_anything_3(
                         "chunks": [],
                         "conf": [],
                         "frames": set(),
-                        "first_time": float(ft[fi]),
+                        "first_time": float(frame_times[fi]),
                     },
                 )
                 r["chunks"].append(pts)
@@ -241,25 +276,39 @@ def adapt_sam3_depth_anything_3(
         if raw:
             instances[cls] = raw
             stats[cls] = {"raw": len(raw), "merged": len(raw), "peak": peak}
-    scene = []
+    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.append(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": np.concatenate(scene, 0),
+            "scene_pts": _sample_scene_points(depth, intr, c2w),
             "cameras": c2w[:, :3, 3],
             "raw_inputs": {
                 "depth": depth,
                 "intr": intr,
                 "c2w": c2w,
                 "conf": conf,
-                "ftimes": ft,
+                "ftimes": frame_times,
                 "per": per,
             },
         }
@@ -272,7 +321,9 @@ def adapt_sam3_depth_anything_3(
 # ==========================================================================================
 
 
-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("|")
+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):
@@ -299,7 +350,9 @@ def _decode_segvggt_raw(path):
     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)
+        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]
@@ -316,14 +369,11 @@ def _decode_segvggt_raw(path):
 
     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 = 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:
@@ -332,9 +382,7 @@ def _decode_segvggt_raw(path):
         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, _ = pose_encoding_to_extri_intri(raw["pose_enc"].float(), image_size)
     extrinsics = extrinsics[0].cpu().numpy()
     rotations = extrinsics[:, :3, :3]
     translations = extrinsics[:, :3, 3]
@@ -358,7 +406,8 @@ def _decode_segvggt_raw(path):
 
 def adapt_segvggt(root=None, path=None, scene=None, **_):
     """Translate a raw-preserving SegVGGT cache to canonical geometry."""
-    if path is None and root and scene:
+    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

encoder/config.py

@@ -13,11 +13,10 @@ DATA_ROOT = Path(os.environ.get("VSI_DATA_ROOT", "/workspace/data"))
 VSI_ROOT = Path(os.environ.get("VSI_ROOT", "/root/data/VSI-Bench"))
 JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
 CACHE_ROOT = Path(os.environ.get("VSI_CACHE_ROOT", "/root/data/caches"))
-CODES_ROOT = Path(
-    os.environ.get("VSI_CODES", DATA_ROOT / "spatial codes")
-)
+CODES_ROOT = Path(os.environ.get("VSI_CODES", "/root/workspace/spatial codes"))
 VIDEO_DATASETS = ("scannet", "scannetpp", "arkitscenes")
 
+
 def video_path(scene: str, dataset: str | None = None) -> str:
     """Return the unique MP4 for ``scene`` from the VSI-Bench dataset folders."""
     scene = str(scene)

encoder/geometric.py

@@ -102,10 +102,10 @@ 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)."""
-    P = np.concatenate([i["pts"] for v in instances.values() for i in v], 0)
-    ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+    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(P[:, up], bins=80)
+    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)
@@ -119,10 +119,10 @@ def room_gravity(
     """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)."""
-    P = []
+    points = []
     for f in range(0, len(depth), fstride):
-        Hd, Wd = depth[f].shape
-        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        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]
@@ -132,15 +132,24 @@ def room_gravity(
         ys, xs, z = ys[ok], xs[ok], z[ok]
         if not len(z):
             continue
-        K = intr[f]
-        Xc = np.stack(
-            [(xs - K[0, 2]) * z / K[0, 0], (ys - K[1, 2]) * z / K[1, 1], z], 1
+        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,
         )
-        P.append((c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3])
-    P = np.concatenate(P).astype(np.float64) if P else np.zeros((0, 3))
+        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(P) < 100:  # fallback to axis-extent
-        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0) if len(P) else np.ones(3)
+    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
@@ -149,14 +158,14 @@ def room_gravity(
     best = None
     best_score = -1
     for _ in range(iters):
-        a, b, c = P[rng.choice(len(P), 3, False)]
+        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 = P @ nrm + d
+        side = points @ nrm + d
         ninl = int((np.abs(side) < thr).sum())
         if ninl < 50:
             continue
@@ -167,7 +176,7 @@ def room_gravity(
             best_score = score
             best = (nrm, d)
     if best is None:
-        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
         ax = int(np.argmin(ext))
         g = np.zeros(3)
         g[ax] = 1.0
@@ -314,7 +323,7 @@ def _rep(insts):
     return max(insts, key=lambda i: i["n"])
 
 
-def answer_rel_direction(pA, pB, pC, up_vec, up_ax, mode="hard"):
+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
@@ -326,14 +335,14 @@ def answer_rel_direction(pA, pB, pC, up_vec, up_ax, mode="hard"):
         w = v.astype(np.float64)
         return w - (w @ g) * g
 
-    fwd = fl(pB - pA)
+    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(pC - pA)
+    d = fl(point_c - point_a)
     f = float(d @ fwd)
     lateral = float(d @ left)
     if mode == "medium":
@@ -431,10 +440,10 @@ def _sor(pts, k=16, std=2.0, cap=4000):
     if len(pts) < k + 2:
         return pts
     rs = np.random.RandomState(0)
-    P = pts if len(pts) <= cap else pts[rs.choice(len(pts), cap, False)]
-    d, _ = cKDTree(P).query(P, k=k + 1, workers=KD_WORKERS)
+    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 P[md <= md.mean() + std * md.std()]
+    return points[md <= md.mean() + std * md.std()]
 
 
 def _main_cluster(pts):
@@ -498,21 +507,21 @@ def _clean(inst, cap=4000):
     return pts
 
 
-def answer_closest_distance(instsA, instsB, k=4000):
+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."""
-    A = _clean(_rep(instsA), cap=k)
-    B = _clean(_rep(instsB), cap=k)
-    if len(A) == 0 or len(B) == 0:
+    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(A) <= len(B):
-        d, _ = cKDTree(A).query(B, k=1, workers=KD_WORKERS)
+    if len(points_a) <= len(points_b):
+        d, _ = cKDTree(points_a).query(points_b, k=1, workers=KD_WORKERS)
     else:
-        d, _ = cKDTree(B).query(A, k=1, workers=KD_WORKERS)
+        d, _ = cKDTree(points_b).query(points_a, k=1, workers=KD_WORKERS)
     return float(d.min())
 
 
@@ -600,7 +609,7 @@ def refine_mask(mask, rgb):
 
 def backproject_frame(
     depth_f,
-    K,
+    intrinsics,
     c2w_f,
     mask_f,
     conf_f=None,
@@ -614,15 +623,15 @@ def backproject_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)."""
-    Hd, Wd = depth_f.shape
+    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 != (Hd, Wd):
+    if mask_f.shape != (height, width):
         mask_f = cv2.resize(
-            mask_f.astype(np.uint8), (Wd, Hd), interpolation=cv2.INTER_NEAREST
+            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)
@@ -655,17 +664,24 @@ def backproject_frame(
         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 = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
-    Xc = np.stack([(xs - cx) * z / fx, (ys - cy) * z / fy, z], axis=1)  # camera coords
-    Xw = (c2w_f[:3, :3] @ Xc.T).T + c2w_f[:3, 3]  # -> world
+    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 Xw.astype(np.float32), cw
-    return Xw.astype(np.float32)
+        return world_points.astype(np.float32), cw
+    return world_points.astype(np.float32)
 
 
 # ==========================================================================================
@@ -686,25 +702,31 @@ def robust_centroid_extent(pts, up_axis=None):
     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)
-    X = pts - c
-    if len(X) > 5000:  # PCA on a sample (deterministic)
-        X = X[np.random.RandomState(0).choice(len(X), 5000, False)]
+    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]
-        F = X[:, floor_axes]
+        floor_points = centered[:, floor_axes]
         try:
-            _, _, Vt2 = np.linalg.svd(F - F.mean(0), full_matrices=False)
-            proj_floor = F @ Vt2.T  # (N,2) along the object's own floor-plane axes
+            _, _, 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 = F
-        up_col = X[:, up_axis : up_axis + 1]  # up axis untouched (yaw-only)
+            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:
-            _, _, Vt = np.linalg.svd(X - X.mean(0), full_matrices=False)
-            proj = X @ Vt.T  # coordinates along principal axes
+            _, _, rotation = np.linalg.svd(
+                centered - centered.mean(0), full_matrices=False
+            )
+            proj = centered @ rotation.T  # coordinates along principal axes
         except np.linalg.LinAlgError:
-            proj = X
+            proj = centered
     lo = np.percentile(proj, 2, axis=0)
     hi = np.percentile(proj, 98, axis=0)
     ext = np.maximum(hi - lo, 0.0)
@@ -864,7 +886,7 @@ def build_instances(
                     if (conf_f is not None and CONF_PCT > 0)
                     else 0.0
                 )
-                Xw, cw = backproject_frame(
+                world_points, cw = backproject_frame(
                     depth[fidx],
                     intr[fidx],
                     c2w[fidx],
@@ -875,8 +897,8 @@ def build_instances(
                     return_conf=True,
                     edges_f=edges.get(fidx),
                 )
-                if len(Xw):
-                    pts_by_id.setdefault(oid, []).append(Xw)
+                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)
@@ -966,8 +988,8 @@ def class_spatial_code(insts, peak=0):
 def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
     pts = []
     for f in range(depth.shape[0]):
-        Hd, Wd = depth[f].shape
-        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        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]
@@ -979,14 +1001,19 @@ def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
         ys, xs, z = ys[ok], xs[ok], z[ok]
         if not len(z):
             continue
-        K = intr[f]
-        fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
-        Xc = np.stack([(xs - cx) * z / fx, (ys - cy) * z / fy, z], 1)
-        Xw = (c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3]
-        pts.append(Xw.astype(np.float32))
+        intrinsics = intr[f]
+        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], 1)
+        world_points = (c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3]
+        pts.append(world_points.astype(np.float32))
     if not pts:
         return 0.0
-    P = np.concatenate(pts, 0)
+    points = np.concatenate(pts, 0)
     if up_vec is not None:
         # VSI-faithful: area in the plane orthogonal to GRAVITY (RANSAC floor normal), like the
         # benchmark's gravity-aligned GT meshes. Build an orthonormal in-plane basis (u, v).
@@ -996,43 +1023,45 @@ def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
         u = np.cross(g, a)
         u /= np.linalg.norm(u)
         v = np.cross(g, u)
-        F_full = np.stack([P @ u, P @ v], 1)
+        all_floor_points = np.stack([points @ u, points @ v], 1)
     else:
         up = int(
-            np.argmin(P.max(0) - P.min(0))
+            np.argmin(points.max(0) - points.min(0))
         )  # legacy: vertical = smallest-extent axis
         floor_axes = [i for i in range(3) if i != up]
-        F_full = P[:, floor_axes]
+        all_floor_points = points[:, floor_axes]
     # VSI-Bench room-size definition = alpha-shape of the floor-plane point cloud (confirmed in their
     # paper appendix). VSI does not publish the alpha value they use for their own GT mesh, so alpha=2
     # here is NOT a matched/verified constant -- it was chosen empirically for this pipeline's own
     # (sparser) reconstructed point density. This is the one disclosed benchmark-adjacent tuned constant
     # in the whole file; everything else is exact/derived or a generic, non-tuned statistical convention.
     # (Falls back to enclosed-fill below if the alphashape package isn't available.)
-    F = F_full
-    lo = np.percentile(F, 0.5, 0)
-    hi = np.percentile(F, 99.5, 0)  # gentle clip (preserve room extent)
-    F = F[
-        (F[:, 0] >= lo[0])
-        & (F[:, 0] <= hi[0])
-        & (F[:, 1] >= lo[1])
-        & (F[:, 1] <= hi[1])
+    floor_points = all_floor_points
+    lo = np.percentile(floor_points, 0.5, 0)
+    hi = np.percentile(floor_points, 99.5, 0)  # gentle clip (preserve room extent)
+    floor_points = floor_points[
+        (floor_points[:, 0] >= lo[0])
+        & (floor_points[:, 0] <= hi[0])
+        & (floor_points[:, 1] >= lo[1])
+        & (floor_points[:, 1] <= hi[1])
     ]
-    if len(F) < 10:
+    if len(floor_points) < 10:
         return 0.0
     try:
         import alphashape
 
-        idx = np.random.RandomState(0).choice(len(F), min(10000, len(F)))
+        idx = np.random.RandomState(0).choice(
+            len(floor_points), min(10000, len(floor_points))
+        )
         return round(
-            float(alphashape.alphashape(F[idx], alpha=2).area), 1
+            float(alphashape.alphashape(floor_points[idx], alpha=2).area), 1
         )  # alpha=2 tuned for recon density
     except Exception:
         from scipy import ndimage
 
         res = 0.10
-        ai = ((F[:, 0] - F[:, 0].min()) / res).astype(int)
-        bi = ((F[:, 1] - F[:, 1].min()) / res).astype(int)
+        ai = ((floor_points[:, 0] - floor_points[:, 0].min()) / res).astype(int)
+        bi = ((floor_points[:, 1] - floor_points[:, 1].min()) / 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))
@@ -1063,8 +1092,8 @@ def _room_outline(depth, intr, c2w, conf, bu, bv):
 
     pts, stride = [], 8
     for f in range(0, depth.shape[0], 3):
-        Hd, Wd = depth[f].shape
-        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        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]
@@ -1074,31 +1103,38 @@ def _room_outline(depth, intr, c2w, conf, bu, bv):
         ys, xs, z = ys[ok], xs[ok], z[ok]
         if not len(z):
             continue
-        K = intr[f]
-        Xc = np.stack(
-            [(xs - K[0, 2]) * z / K[0, 0], (ys - K[1, 2]) * z / K[1, 1], z], 1
+        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)
         )
-        pts.append(((c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3]).astype(np.float32))
     if not pts:
         return []
-    Pw = np.concatenate(pts, 0)
-    P = np.stack(
-        [Pw @ bu, Pw @ bv], 1
+    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(P, 0.5, 0)
-    hi = np.percentile(P, 99.5, 0)
-    P = P[
-        (P[:, 0] >= lo[0])
-        & (P[:, 0] <= hi[0])
-        & (P[:, 1] >= lo[1])
-        & (P[:, 1] <= hi[1])
+    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(P) < 10:
+    if len(points) < 10:
         return []
     res = 0.10
-    x0, y0 = P[:, 0].min(), P[:, 1].min()
-    ai = ((P[:, 0] - x0) / res).astype(int)
-    bi = ((P[:, 1] - y0) / res).astype(int)
+    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))
@@ -1131,8 +1167,8 @@ def build_spatial_code_raw(depth, intr, c2w, conf, ftimes, per):
     # emission-time class rename: VSI's questions say 'coat rack' while their annotations
     # (and hence the SAM3 prompt + caches) say 'coat hanger' -- same object, their naming
     # seam. The model sees questions, so emitted codes follow the question vocabulary.
-    _ALIAS = {"coat hanger": "coat rack"}
-    per = {_ALIAS.get(k, k): v for k, v in per.items()}
+    class_aliases = {"coat hanger": "coat rack"}
+    per = {class_aliases.get(k, k): v for k, v in per.items()}
     inst, stats = build_instances(per, depth, intr, c2w, conf, ftimes)
     up_vec, up_ax = room_gravity(
         depth, intr, c2w, conf
@@ -1140,8 +1176,8 @@ def build_spatial_code_raw(depth, intr, c2w, conf, ftimes, per):
     bu, bv, bg = _floor_basis(
         up_vec
     )  # shared gravity floor frame (bu,bv horizontal, bg up)
-    P = np.concatenate([i["pts"] for cl in inst.values() for i in cl], 0)
-    floor_level = _floor_level(P, bg)
+    points = np.concatenate([i["pts"] for cl in inst.values() for i in cl], 0)
+    floor_level = _floor_level(points, bg)
     fa = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
     code = to_spatial_code(inst, stats, fa, up_ax, up_vec, floor_level)
     cls = list(inst.keys())
@@ -1192,19 +1228,23 @@ def dump_spatial_code(code, path):
 
 
 # Canonical world-space fallback used by SegVGGT and similar adapters.
-def _canonical_room_gravity(P, cameras=None, iters=300, thr=0.05):
+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."""
-    P = np.asarray(P, np.float64)
-    P = P[np.isfinite(P).all(1)]
-    if len(P) > 100000:
-        P = P[np.random.RandomState(0).choice(len(P), 100000, False)]
+    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(P) < 100:
-        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0) if len(P) else np.ones(3)
+    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
@@ -1213,14 +1253,14 @@ def _canonical_room_gravity(P, cameras=None, iters=300, thr=0.05):
     best = None
     best_score = -1
     for _ in range(iters):
-        a, b, c = P[rng.choice(len(P), 3, False)]
+        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 = P @ nrm + d
+        side = points @ nrm + d
         ninl = int((np.abs(side) < thr).sum())
         if ninl < 50:
             continue
@@ -1229,7 +1269,7 @@ def _canonical_room_gravity(P, cameras=None, iters=300, thr=0.05):
             best_score = score
             best = (nrm, d)
     if best is None:
-        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+        ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
         ax = int(np.argmin(ext))
         g = np.zeros(3)
         g[ax] = 1.0
@@ -1258,24 +1298,28 @@ def _canonical_floor_basis(up_vec):
 
 def _canonical_robust_centroid_extent(pts, up_axis=None):
     c = np.median(pts, axis=0)
-    X = pts - c
-    if len(X) > 5000:
-        X = X[np.random.RandomState(0).choice(len(X), 5000, False)]
+    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]
-        F = X[:, floor_axes]
+        floor_points = centered[:, floor_axes]
         try:
-            _, _, Vt2 = np.linalg.svd(F - F.mean(0), full_matrices=False)
-            proj_floor = F @ Vt2.T
+            _, _, 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 = F
-        proj = np.concatenate([proj_floor, X[:, up_axis : up_axis + 1]], 1)
+            proj_floor = floor_points
+        proj = np.concatenate([proj_floor, centered[:, up_axis : up_axis + 1]], 1)
     else:
         try:
-            _, _, Vt = np.linalg.svd(X - X.mean(0), full_matrices=False)
-            proj = X @ Vt.T
+            _, _, rotation = np.linalg.svd(
+                centered - centered.mean(0), full_matrices=False
+            )
+            proj = centered @ rotation.T
         except np.linalg.LinAlgError:
-            proj = X
+            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)
@@ -1348,14 +1392,14 @@ def _canonical_sor(pts, k=16, std=2.0, cap=4000):
 
     if len(pts) < k + 2:
         return pts
-    P = (
+    points = (
         pts
         if len(pts) <= cap
         else pts[np.random.RandomState(0).choice(len(pts), cap, False)]
     )
-    d, _ = cKDTree(P).query(P, k=k + 1, workers=KD_WORKERS)
+    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
     md = d[:, 1:].mean(1)
-    return P[md <= md.mean() + std * md.std()]
+    return points[md <= md.mean() + std * md.std()]
 
 
 def _canonical_clean(inst, cap=4000):
@@ -1379,27 +1423,27 @@ def _canonical_rep(insts):
     return max(insts, key=lambda i: (i.get("n", len(i["pts"])), i.get("nframes", 0)))
 
 
-def _canonical_answer_closest_distance(instsA, instsB, k=4000):
+def _canonical_answer_closest_distance(instances_a, instances_b, k=4000):
     from scipy.spatial import cKDTree
 
-    A, B = (
-        _canonical_clean(_canonical_rep(instsA), k),
-        _canonical_clean(_canonical_rep(instsB), k),
+    points_a, points_b = (
+        _canonical_clean(_canonical_rep(instances_a), k),
+        _canonical_clean(_canonical_rep(instances_b), k),
     )
-    if not len(A) or not len(B):
+    if not len(points_a) or not len(points_b):
         return float("inf")
     d, _ = (
-        cKDTree(A).query(B, workers=KD_WORKERS)
-        if len(A) <= len(B)
-        else cKDTree(B).query(A, workers=KD_WORKERS)
+        cKDTree(points_a).query(points_b, workers=KD_WORKERS)
+        if len(points_a) <= len(points_b)
+        else cKDTree(points_b).query(points_a, workers=KD_WORKERS)
     )
     return float(d.min())
 
 
-def _canonical_compute_floor_area(P, up_vec):
-    P = np.asarray(P, np.float32)
-    P = P[np.isfinite(P).all(1)]
-    if not len(P):
+def _canonical_compute_floor_area(points, up_vec):
+    points = np.asarray(points, np.float32)
+    points = points[np.isfinite(points).all(1)]
+    if not len(points):
         return 0.0
     g = np.asarray(up_vec, np.float64)
     g /= np.linalg.norm(g) + 1e-12
@@ -1407,27 +1451,29 @@ def _canonical_compute_floor_area(P, up_vec):
     u = np.cross(g, a)
     u /= np.linalg.norm(u)
     v = np.cross(g, u)
-    F = np.stack([P @ u, P @ v], 1)
-    lo, hi = (np.percentile(F, 0.5, 0), np.percentile(F, 99.5, 0))
-    F = F[
-        (F[:, 0] >= lo[0])
-        & (F[:, 0] <= hi[0])
-        & (F[:, 1] >= lo[1])
-        & (F[:, 1] <= hi[1])
+    floor_points = np.stack([points @ u, points @ v], 1)
+    lo, hi = (np.percentile(floor_points, 0.5, 0), np.percentile(floor_points, 99.5, 0))
+    floor_points = floor_points[
+        (floor_points[:, 0] >= lo[0])
+        & (floor_points[:, 0] <= hi[0])
+        & (floor_points[:, 1] >= lo[1])
+        & (floor_points[:, 1] <= hi[1])
     ]
-    if len(F) < 10:
+    if len(floor_points) < 10:
         return 0.0
     try:
         import alphashape
 
-        idx = np.random.RandomState(0).choice(len(F), min(10000, len(F)))
-        return round(float(alphashape.alphashape(F[idx], alpha=2).area), 1)
+        idx = np.random.RandomState(0).choice(
+            len(floor_points), min(10000, len(floor_points))
+        )
+        return round(float(alphashape.alphashape(floor_points[idx], alpha=2).area), 1)
     except Exception:
         from scipy import ndimage
 
         res = 0.1
-        ai = ((F[:, 0] - F[:, 0].min()) / res).astype(int)
-        bi = ((F[:, 1] - F[:, 1].min()) / res).astype(int)
+        ai = ((floor_points[:, 0] - floor_points[:, 0].min()) / res).astype(int)
+        bi = ((floor_points[:, 1] - floor_points[:, 1].min()) / 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))

encoder/launch.py

@@ -17,11 +17,11 @@ 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 as C
+from encoder import config  # noqa: E402
 
 
 def _scenes():
-    with open(C.JSONL) as f:
+    with open(config.JSONL) as f:
         return list(dict.fromkeys(str(json.loads(line)["scene_name"]) for line in f))
 
 
@@ -62,7 +62,7 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("scene", nargs="?")
     p.add_argument("--all", action="store_true")
-    p.add_argument("--model", default=C.MODEL)
+    p.add_argument("--model", default=config.MODEL)
     p.add_argument(
         "--workers",
         type=int,
@@ -76,7 +76,7 @@ def main():
     pending = []
     completed = 0
     for scene in scenes:
-        if os.path.exists(C.spatial_code_path(scene, a.model)) and not a.rebuild:
+        if os.path.exists(config.spatial_code_path(scene, a.model)) and not a.rebuild:
             completed += 1
             print(f"[{completed}/{len(scenes)}] {scene}: skipped", flush=True)
         else:

encoder/render.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import os
 
-from encoder import config as C
+from encoder import config
 from encoder import geometric as geometry_math
 from encoder import run as perceive
 
@@ -17,7 +17,7 @@ def build_spatial_code_for(scene, model=None, rebuild=False):
 
 def write_spatial_code_for(scene, model=None, rebuild=False):
     code, how = build_spatial_code_for(scene, model, rebuild)
-    path = C.spatial_code_path(scene, model)
+    path = config.spatial_code_path(scene, model)
     os.makedirs(os.path.dirname(path), exist_ok=True)
     geometry_math.dump_spatial_code(code, path)
     return code, how, path

encoder/run.py

@@ -13,14 +13,14 @@ 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
-from encoder import config as C
+from encoder import adapters  # noqa: E402
+from encoder import config  # noqa: E402
 
 
 def cache_or_load(scene: str, model: str | None = None, rebuild: bool = False):
     """Return canonical geometry, reusing ``<scene>.pkl.gz`` when available."""
-    model = model or C.MODEL
-    path = C.cache_file(scene, model)
+    model = model or config.MODEL
+    path = config.cache_file(scene, model)
     if os.path.exists(path) and not rebuild:
         with gzip.open(path, "rb") as f:
             return adapters.validate(pickle.load(f)), "loaded"
@@ -28,7 +28,7 @@ def cache_or_load(scene: str, model: str | None = None, rebuild: bool = False):
     geometry = adapters.adapt(
         model,
         scene=scene,
-        root=str(C.CACHE_ROOT),
+        root=str(config.CACHE_ROOT),
         rebuild=rebuild,
     )
     os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -40,7 +40,7 @@ def cache_or_load(scene: str, model: str | None = None, rebuild: bool = False):
 def main() -> None:
     p = argparse.ArgumentParser()
     p.add_argument("scene")
-    p.add_argument("--model", default=C.MODEL)
+    p.add_argument("--model", default=config.MODEL)
     p.add_argument("--rebuild", action="store_true")
     a = p.parse_args()
     geometry, how = cache_or_load(a.scene, a.model, a.rebuild)

inference/adapters.py

@@ -11,6 +11,31 @@ import sys
 import numpy as np
 
 
+def _sample_video_frames(path, frame_count):
+    """Decode one shared set of evenly spaced RGB frames for every model adapter."""
+    import cv2
+
+    capture = cv2.VideoCapture(path)
+    if not capture.isOpened():
+        raise RuntimeError(f"cannot open video: {path}")
+    try:
+        fps = capture.get(cv2.CAP_PROP_FPS) or 1.0
+        total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+        if total < frame_count:
+            raise ValueError(f"{path} has {total} frames; {frame_count} are required")
+        indices = np.linspace(0, total - 1, frame_count, dtype=int)
+        frames = []
+        for index in indices:
+            capture.set(cv2.CAP_PROP_POS_FRAMES, int(index))
+            ok, frame = capture.read()
+            if not ok:
+                raise RuntimeError(f"failed reading frame {index} from {path}")
+            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    finally:
+        capture.release()
+    return np.stack(frames), indices.astype(np.float32) / fps
+
+
 class InferenceAdapter(ABC):
     """Common interface implemented by every inference backend."""
 
@@ -76,9 +101,7 @@ class SegVGGTAdapter(InferenceAdapter):
             config = compose(config_name="segvggt_scannet200")
         model = instantiate(config.model, _recursive_=False)
         state = torch.load(self.checkpoint, map_location="cpu")
-        model.load_state_dict(
-            state["model"] if "model" in state else state, strict=False
-        )
+        model.load_state_dict(state.get("model", state), strict=False)
         self.model = model.to(self.device).to(self.dtype).eval()
         self.runtime = torch
 
@@ -86,36 +109,19 @@ class SegVGGTAdapter(InferenceAdapter):
     def _read_video(path, frame_count):
         import cv2
 
-        capture = cv2.VideoCapture(path)
-        if not capture.isOpened():
-            raise RuntimeError(f"cannot open video: {path}")
-        try:
-            fps = capture.get(cv2.CAP_PROP_FPS) or 1.0
-            total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
-            if total < frame_count:
-                raise ValueError(
-                    f"{path} has {total} frames; {frame_count} are required"
-                )
-            indices = np.linspace(0, total - 1, frame_count, dtype=int)
-            frames = []
-            for index in indices:
-                capture.set(cv2.CAP_PROP_POS_FRAMES, int(index))
-                ok, frame = capture.read()
-                if not ok:
-                    raise RuntimeError(f"failed reading frame {index} from {path}")
-                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                height, width = frame.shape[:2]
-                new_height = max(14, round(height * 518 / width / 14) * 14)
-                frame = cv2.resize(
-                    frame, (518, new_height), interpolation=cv2.INTER_LANCZOS4
-                )
-                if new_height > 518:
-                    offset = (new_height - 518) // 2
-                    frame = frame[offset : offset + 518]
-                frames.append(frame)
-        finally:
-            capture.release()
-        return np.stack(frames), indices.astype(np.float32) / fps
+        raw_frames, frame_times = _sample_video_frames(path, frame_count)
+        frames = []
+        for frame in raw_frames:
+            height, width = frame.shape[:2]
+            new_height = max(14, round(height * 518 / width / 14) * 14)
+            frame = cv2.resize(
+                frame, (518, new_height), interpolation=cv2.INTER_LANCZOS4
+            )
+            if new_height > 518:
+                offset = (new_height - 518) // 2
+                frame = frame[offset : offset + 518]
+            frames.append(frame)
+        return np.stack(frames), frame_times
 
     def run_scene(self, video_path, output_path, frame_count):
         if self.model is None or self.runtime is None:
@@ -164,9 +170,7 @@ class DepthAnything3Adapter(InferenceAdapter):
     def __init__(self, model_root=None, checkpoint=None):
         self.model_root = Path(
             model_root
-            or os.environ.get(
-                "VSI_DA3_ROOT", "/root/models/depth-anything-3"
-            )
+            or os.environ.get("VSI_DA3_ROOT", "/root/models/depth-anything-3")
         )
         self.checkpoint = Path(
             checkpoint
@@ -203,35 +207,13 @@ class DepthAnything3Adapter(InferenceAdapter):
 
     @staticmethod
     def _read_video(path, frame_count):
-        import cv2
-
-        capture = cv2.VideoCapture(path)
-        if not capture.isOpened():
-            raise RuntimeError(f"cannot open video: {path}")
-        try:
-            total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
-            if total < frame_count:
-                raise ValueError(
-                    f"{path} has {total} frames; {frame_count} are required"
-                )
-            frames = []
-            for index in np.linspace(0, total - 1, frame_count, dtype=int):
-                capture.set(cv2.CAP_PROP_POS_FRAMES, int(index))
-                ok, frame = capture.read()
-                if not ok:
-                    raise RuntimeError(f"failed reading frame {index} from {path}")
-                frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-            return frames
-        finally:
-            capture.release()
+        frames, _ = _sample_video_frames(path, frame_count)
+        return list(frames)
 
-    def run_scene(self, video_path, output_path, frame_count):
+    def run_frames(self, frames, output_path):
         if self.model is None:
-            raise RuntimeError("load_model() must be called before run_scene()")
-        prediction = self.model.inference(
-            self._read_video(video_path, frame_count),
-            export_dir=None,
-        )
+            raise RuntimeError("load_model() must be called before run_frames()")
+        prediction = self.model.inference(list(frames), export_dir=None)
         output = Path(output_path)
         output.parent.mkdir(parents=True, exist_ok=True)
         temporary = output.with_suffix(output.suffix + ".tmp")
@@ -239,6 +221,9 @@ class DepthAnything3Adapter(InferenceAdapter):
             pickle.dump(prediction, stream, protocol=pickle.HIGHEST_PROTOCOL)
         os.replace(temporary, output)
 
+    def run_scene(self, video_path, output_path, frame_count):
+        self.run_frames(self._read_video(video_path, frame_count), output_path)
+
 
 class SAM3Adapter(InferenceAdapter):
     """Run SAM3 independently on sampled images, with no video tracking."""
@@ -285,11 +270,14 @@ class SAM3Adapter(InferenceAdapter):
         self.processor = Sam3Processor(self.model)
 
     def run_scene(self, video_path, output_path, frame_count):
+        frames, _ = _sample_video_frames(video_path, frame_count)
+        self.run_frames(frames, output_path)
+
+    def run_frames(self, frames, output_path):
         if self.model is None or self.processor is None or self.runtime is None:
-            raise RuntimeError("load_model() must be called before run_scene()")
+            raise RuntimeError("load_model() must be called before run_frames()")
         from PIL import Image
 
-        frames = DepthAnything3Adapter._read_video(video_path, frame_count)
         raw_outputs = []
         with self.runtime.inference_mode():
             for frame in frames:
@@ -324,11 +312,12 @@ class SAM3DepthAnything3Adapter(InferenceAdapter):
 
     def run_scene(self, video_path, output_path, frame_count):
         if not isinstance(output_path, dict):
-            raise TypeError("combined inference requires a model-to-output-path mapping")
-        self.sam3.run_scene(video_path, output_path["sam3"], frame_count)
-        self.depth_anything_3.run_scene(
-            video_path, output_path["depth-anything-3"], frame_count
-        )
+            raise TypeError(
+                "combined inference requires a model-to-output-path mapping"
+            )
+        frames, _ = _sample_video_frames(video_path, frame_count)
+        self.sam3.run_frames(frames, output_path["sam3"])
+        self.depth_anything_3.run_frames(frames, output_path["depth-anything-3"])
 
 
 _ADAPTERS = {

inference/run.py

@@ -17,9 +17,7 @@ from inference import adapters  # noqa: E402
 def output_paths(scene, model):
     """Return every adapter-owned raw-cache path for one inference selection."""
     return {
-        target: str(
-            Path(inference_config.model_cache_dir(target)) / f"{scene}{suffix}"
-        )
+        target: str(Path(inference_config.model_cache_dir(target)) / f"{scene}{suffix}")
         for target, suffix in adapters.output_targets(model).items()
     }
 
@@ -44,9 +42,7 @@ def run_scene(
     if owns_adapter:
         adapter.load_model(device or "cuda")
     adapter_output = (
-        next(iter(destinations.values()))
-        if len(destinations) == 1
-        else destinations
+        next(iter(destinations.values())) if len(destinations) == 1 else destinations
     )
     adapter.run_scene(inference_config.video_path(scene), adapter_output, frame_count)
     return "built", output_path(scene, model)

symbolic/launch.py

@@ -1,5 +1,5 @@
 """Runs the symbolic engine (via symbolic/run.py's score_scene()) across EVERY scene that has
-a real spatial code on disk under /workspace/data/spatial codes/segvggt/ -- the multi-scene
+a real spatial code under /root/workspace/spatial codes/<MODEL>/ -- the multi-scene
 orchestrator, matching encoder/launch.py's and harness/launch.py's own single-scene-worker vs.
 multi-scene-orchestrator split (symbolic/run.py stays single-scene only; this file is the only
 one that loops over more than one scene). This file contains no scoring logic of its own --
@@ -8,7 +8,7 @@ unmodified vsi_official_eval.py) is symbolic/run.py's score_scene(), called once
 
 Usage:
     python symbolic/launch.py
-        Every scene under /workspace/data/spatial codes/segvggt/*.json that also has at least one real
+        Every scene under /root/workspace/spatial codes/<MODEL>/*.json that also has at least one real
         question in test.jsonl -- runs each one (delegating to symbolic/run.py's score_scene()
         for the actual work), prints a per-scene report (including the appearance-order
         diagnostic run.py builds), then one combined aggregate across every scene together.

symbolic/run.py

@@ -6,7 +6,7 @@ orchestrator (matches encoder/launch.py's and harness/launch.py's own single-sce
 multi-scene-orchestrator split: this file never loops over more than one scene on its own).
 
 FETCHES the spatial code from:
-    /workspace/data/spatial codes/segvggt/<SCENE_ID>.json
+    /root/workspace/spatial codes/<MODEL>/<SCENE_ID>.json
 (the model-specific on-disk layout). This file does NOT
 build spatial codes (that's encoder/render.py's job) and does NOT call any model -- it only
 reads an already-built spatial_code.json and answers/scores against it.
@@ -87,9 +87,7 @@ _AUTO_WORKSPACE = _find_workspace_root(_HERE)
 
 
 def _default_spatial_codes_root():
-    if _AUTO_WORKSPACE is not None:
-        return os.path.join(_AUTO_WORKSPACE, "data", "spatial codes")
-    return "/workspace/data/spatial codes"
+    return "/root/workspace/spatial codes"
 
 
 def _default_test_jsonl():
@@ -144,7 +142,7 @@ DEFAULT_TEST_JSONL = os.environ.get("SYMBOLIC_TEST_JSONL", _default_test_jsonl()
 
 def spatial_code_path(scene_id):
     """The one place this file looks for a scene's spatial code:
-    /workspace/data/spatial codes/segvggt/<SCENE_ID>.json."""
+    /root/workspace/spatial codes/<MODEL>/<SCENE_ID>.json."""
     return os.path.join(SPATIAL_CODES_DIR, f"{scene_id}.json")
 
 

symbolic/solver.py

@@ -92,16 +92,16 @@ def _instance_xy(code, cls_name, index=0):
     return (_parse_meters(pos["x coordinate"]), _parse_meters(pos["y coordinate"]))
 
 
-def _rel_direction(pA, pB, pC, mode="hard"):
+def _rel_direction(point_a, point_b, point_c, mode="hard"):
     """Standing at A facing B, where is C? Same formula as
     encoder/geometric.py's answer_rel_direction(), specialized to the 2D floor plane (the
     spatial code's frame has no raw height needed for this -- direction is a floor-plane
     question in every real VSI-Bench phrasing). front/back = dot(C-A, fwd);
     left/right = dot(C-A, left), where left = fwd rotated +90 degrees (matches the
     right-handed convention answer_rel_direction() documents)."""
-    ax, ay = pA
-    bx, by = pB
-    cx, cy = pC
+    ax, ay = point_a
+    bx, by = point_b
+    cx, cy = point_c
     fwd = (bx - ax, by - ay)
     n = (fwd[0] ** 2 + fwd[1] ** 2) ** 0.5
     if n < 1e-9:
@@ -374,14 +374,14 @@ def _answer_rel_direction_typed(question, options, code, mode):
     c_cls = _find_class(m2.group(1), code)
     if a_cls is None or b_cls is None or c_cls is None:
         return None
-    pA, pB, pC = (
+    point_a, point_b, point_c = (
         _instance_xy(code, a_cls),
         _instance_xy(code, b_cls),
         _instance_xy(code, c_cls),
     )
-    if pA is None or pB is None or pC is None:
+    if point_a is None or point_b is None or point_c is None:
         return None
-    result = _rel_direction(pA, pB, pC, mode=mode)
+    result = _rel_direction(point_a, point_b, point_c, mode=mode)
     if result is None:
         return None
     for opt in options:
@@ -527,7 +527,8 @@ def _demo_questions():
     ground truth (this scene's own uploaded spatial_code.json doesn't carry official VSI-Bench
     question/ground_truth pairs alongside it) -- see symbolic/test_symbolic.py for real
     accuracy checks against actual test.jsonl rows."""
-    order = json.load(open("/tmp/final_spatial_code.json")).get("appearance order", [])
+    with open("/tmp/final_spatial_code.json") as stream:
+        order = json.load(stream).get("appearance order", [])
     subset = [c for c in ["bed", "chair", "table", "tv"] if c in order]
     subset_sorted = sorted(subset, key=lambda c: order.index(c))
     ao_correct = ", ".join(subset_sorted)
@@ -627,7 +628,8 @@ def main():
             f"\nNo spatial_code.json found at any of {candidates} -- nothing to demo against."
         )
         return
-    code = json.load(open(path))
+    with open(path) as stream:
+        code = json.load(stream)
     if "closest classes distance meters from" not in code:
         print(
             f"\n{path} is not in the final spatial code shape (no "

tests/test_encoder/conftest.py

@@ -0,0 +1,13 @@
+"""Shared import setup for encoder tests."""
+
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+for path in (ROOT, ROOT / "encoder"):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+
+def pytest_configure(config):
+    config.option.importmode = "importlib"

tests/test_encoder/test_adapters.py

@@ -0,0 +1,210 @@
+import gzip
+import pickle
+import sys
+import types
+
+import numpy as np
+import pytest
+
+from encoder import adapters
+
+
+def test_registry_decodes_native_segvggt_dictionary(tmp_path, monkeypatch):
+    torch = pytest.importorskip("torch")
+    evaluation = types.ModuleType("eval.instance_eval_common")
+    evaluation.predict_by_feat_instance = lambda *args, **kwargs: (
+        torch.tensor([[1, 0, 0, 0], [0, 1, 0, 0]], dtype=torch.bool),
+        torch.tensor([0, 2]),
+        torch.ones(2),
+    )
+    pose = types.ModuleType("segvggt.utils.pose_enc")
+    pose.pose_encoding_to_extri_intri = lambda value, size: (
+        torch.cat(
+            [
+                torch.eye(3).reshape(1, 1, 3, 3),
+                torch.zeros(1, 1, 3, 1),
+            ],
+            dim=-1,
+        ),
+        torch.eye(3).reshape(1, 1, 3, 3),
+    )
+    monkeypatch.setitem(sys.modules, "eval.instance_eval_common", evaluation)
+    monkeypatch.setitem(sys.modules, "segvggt.utils.pose_enc", pose)
+
+    path = tmp_path / "scene.pt"
+    torch.save(
+        {
+            "world_points": torch.zeros(1, 1, 2, 2, 3),
+            "instance_maps": torch.zeros(1, 2, 1, 2, 2),
+            "instance_labels": torch.zeros(1, 2, 4),
+            "pose_enc": torch.zeros(1, 1, 9),
+        },
+        path,
+    )
+    result = adapters.adapt("segvggt", path=path)
+    assert list(result["instances"]) == ["chair"]
+    assert result["instances"]["chair"][0]["n"] == 1
+
+
+def _scene():
+    return {
+        "instances": {"chair": [{"pts": [[0, 0, 0]], "best_pts": [[0, 0, 0]]}]},
+        "stats": {"chair": {"raw": 1, "merged": 1, "peak": 1}},
+        "scene_pts": [[0, 0, 0]],
+        "cameras": None,
+    }
+
+
+def test_validate_normalizes_canonical_geometry():
+    result = adapters.validate(_scene())
+    instance = result["instances"]["chair"][0]
+    assert instance["pts"].shape == (1, 3)
+    assert instance["frames"] == set()
+    assert instance["n"] == 1
+
+
+@pytest.mark.parametrize(
+    ("scene", "error"),
+    [
+        ([], TypeError),
+        ({"instances": {}}, ValueError),
+        (
+            {"instances": {"chair": [{"pts": [1, 2, 3]}]}, "scene_pts": [[0, 0, 0]]},
+            ValueError,
+        ),
+    ],
+)
+def test_validate_rejects_invalid_geometry(scene, error):
+    with pytest.raises(error):
+        adapters.validate(scene)
+
+
+def test_adapt_segvggt_reads_flat_npz(tmp_path):
+    path = tmp_path / "scene.npz"
+    world = np.array([[[[0, 0, 1], [1, 0, 1]]]], np.float32)
+    masks = np.array([[[[True, False]]]])
+    np.savez(
+        path,
+        world_points=world,
+        instance_masks=masks,
+        labels=np.array(["chair"], dtype=object),
+        frame_times=np.array([0], np.float32),
+    )
+
+    result = adapters.adapt_segvggt(path=str(path))
+
+    instance = result["instances"]["chair"][0]
+    assert list(result["instances"]) == ["chair"]
+    assert instance["frames"] == {0}
+    assert result["stats"]["chair"] == {"raw": 1, "merged": 1, "peak": 1}
+
+
+def test_adapt_segvggt_requires_existing_cache(tmp_path):
+    with pytest.raises(FileNotFoundError, match="raw cache does not exist"):
+        adapters.adapt_segvggt(path=str(tmp_path / "missing.npz"))
+
+
+def test_adapter_owned_raw_cache_locations(tmp_path, monkeypatch):
+    seen = {}
+    raw_path = tmp_path / "segvggt" / "scene1.pt"
+    raw_path.parent.mkdir()
+    raw_path.touch()
+
+    def fake_segvggt(path):
+        seen["segvggt"] = str(path)
+        return {
+            "world_points": np.zeros((1, 1, 1, 3), np.float32),
+            "instance_masks": np.ones((1, 1, 1, 1), bool),
+            "labels": np.array(["chair"], dtype=object),
+            "camera_positions": np.zeros((1, 3), np.float32),
+        }
+
+    monkeypatch.setattr(adapters, "_decode_segvggt_raw", fake_segvggt)
+    adapters.adapt_segvggt(root=str(tmp_path), scene="scene1")
+    assert seen["segvggt"] == str(raw_path)
+
+
+def test_fusion_adapter_resolves_two_native_model_directories(tmp_path, monkeypatch):
+    seen = {}
+    depth = np.ones((1, 1, 1), np.float32)
+    intr = np.eye(3, dtype=np.float32)[None]
+    c2w = np.eye(4, dtype=np.float32)[None]
+
+    def fake_da3(path):
+        seen["da3"] = str(path)
+        return depth, intr, c2w, None
+
+    def fake_sam3(path):
+        seen["sam3"] = str(path)
+        return {"object": {0: {0: np.ones((1, 1), bool)}}}
+
+    monkeypatch.setattr(adapters, "_load_native_da3", fake_da3)
+    monkeypatch.setattr(adapters, "_load_native_sam3", fake_sam3)
+    adapters.adapt_sam3_depth_anything_3(root=str(tmp_path), scene="scene1")
+    assert seen == {
+        "da3": str(tmp_path / "depth-anything-3" / "scene1.pkl"),
+        "sam3": str(tmp_path / "sam3" / "scene1.pt"),
+    }
+
+
+def test_adapters_default_to_root_data_caches(monkeypatch, tmp_path):
+    monkeypatch.delenv("VSI_CACHE_ROOT", raising=False)
+    seen = {}
+
+    def fake_da3(path):
+        seen["da3"] = str(path)
+        return (
+            np.ones((1, 1, 1), np.float32),
+            np.eye(3, dtype=np.float32)[None],
+            np.eye(4, dtype=np.float32)[None],
+            None,
+        )
+
+    def fake_sam3(path):
+        seen["sam3"] = str(path)
+        return {"object": {0: {0: np.ones((1, 1), bool)}}}
+
+    monkeypatch.setattr(adapters, "_load_native_da3", fake_da3)
+    monkeypatch.setattr(adapters, "_load_native_sam3", fake_sam3)
+    adapters.adapt_sam3_depth_anything_3(scene="scene1")
+    assert seen == {
+        "da3": "/root/data/caches/depth-anything-3/scene1.pkl",
+        "sam3": "/root/data/caches/sam3/scene1.pt",
+    }
+
+
+def test_adapt_segvggt_rejects_missing_npz_fields(tmp_path):
+    path = tmp_path / "broken.npz"
+    np.savez(path, labels=np.array(["chair"], dtype=object))
+    with pytest.raises(KeyError):
+        adapters.adapt_segvggt(path=str(path))
+
+
+def test_adapt_sam3_depth_anything_3_decodes_masks_and_backprojects(tmp_path):
+    da3_path = tmp_path / "scene.da3.npz"
+    depth = np.full((1, 2, 2), 2.0, np.float32)
+    intrinsics = np.eye(3, dtype=np.float32)[None]
+    poses = np.eye(4, dtype=np.float32)[None]
+    np.savez(
+        da3_path,
+        depth=depth,
+        intr=intrinsics,
+        c2w=poses,
+        frame_times=np.array([1.5], np.float32),
+    )
+    mask = np.array([[True, False], [False, True]])
+    packed = {"chair": {0: {7: (np.packbits(mask), mask.shape)}}}
+    mask_path = tmp_path / "scene.sam3.pkl.gz"
+    with gzip.open(mask_path, "wb") as cache:
+        pickle.dump(packed, cache)
+
+    result = adapters.adapt_sam3_depth_anything_3(
+        da3_path=str(da3_path), sam3_path=str(mask_path)
+    )
+
+    instance = result["instances"]["chair"][0]
+    assert instance["frames"] == {0}
+    assert instance["first_time"] == pytest.approx(1.5)
+    np.testing.assert_allclose(instance["pts"], [[0, 0, 2], [2, 2, 2]])
+    assert result["stats"]["chair"] == {"raw": 1, "merged": 1, "peak": 1}
+    assert result["raw_inputs"]["per"]["chair"][0][7].dtype == bool

tests/test_encoder/test_config.py

@@ -0,0 +1,49 @@
+import pytest
+
+from encoder import config
+
+
+def test_cache_and_code_paths_are_flat(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CACHE_ROOT", tmp_path / "caches")
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "spatial codes")
+
+    assert config.cache_file("scene1", "segvggt") == str(
+        tmp_path / "caches/segvggt/scene1.pkl.gz"
+    )
+    assert config.segvggt_cache_file("scene1") == str(
+        tmp_path / "caches/segvggt/scene1.pt"
+    )
+    assert config.da3_cache_file("scene1") == str(
+        tmp_path / "caches/depth-anything-3/scene1.pkl"
+    )
+    assert config.sam3_cache_file("scene1") == str(tmp_path / "caches/sam3/scene1.pt")
+    assert config.spatial_code_path("scene1") == str(
+        tmp_path / "spatial codes/segvggt/scene1.json"
+    )
+    assert config.spatial_code_path("scene1", "sam3+depth-anything-3") == str(
+        tmp_path / "spatial codes/sam3+depth-anything-3/scene1.json"
+    )
+
+
+def test_video_path_searches_dataset_folders(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "VSI_ROOT", tmp_path)
+    path = tmp_path / "arkitscenes" / "41069025.mp4"
+    path.parent.mkdir(parents=True)
+    path.write_bytes(b"video")
+    assert config.video_path("41069025") == str(path)
+
+
+def test_video_path_rejects_unknown_dataset(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "VSI_ROOT", tmp_path)
+    with pytest.raises(ValueError, match="unknown VSI dataset"):
+        config.video_path("scene1", "unknown")
+
+
+def test_video_path_requires_unique_match(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "VSI_ROOT", tmp_path)
+    for dataset in ("scannet", "scannetpp"):
+        path = tmp_path / dataset / "scene1.mp4"
+        path.parent.mkdir(parents=True)
+        path.write_bytes(b"video")
+    with pytest.raises(RuntimeError, match="multiple datasets"):
+        config.video_path("scene1")

tests/test_encoder/test_encoder.py

@@ -0,0 +1,70 @@
+import numpy as np
+import pytest
+
+import geometric
+
+
+def test_backproject_frame_applies_intrinsics_pose_and_confidence():
+    depth = np.array([[2.0, 2.0], [2.0, np.nan]], np.float32)
+    mask = np.ones((2, 2), bool)
+    intrinsics = np.eye(3, dtype=np.float32)
+    pose = np.eye(4, dtype=np.float32)
+    pose[0, 3] = 1.0
+    confidence = np.array([[0.9, 0.8], [0.1, 1.0]], np.float32)
+
+    points, kept_confidence = geometric.backproject_frame(
+        depth, intrinsics, pose, mask, confidence, conf_thr=0.5, return_conf=True
+    )
+
+    np.testing.assert_allclose(points, [[1.0, 0.0, 2.0], [3.0, 0.0, 2.0]])
+    np.testing.assert_allclose(kept_confidence, [0.9, 0.8])
+
+
+def test_backproject_frame_returns_typed_empty_array():
+    points = geometric.backproject_frame(
+        np.zeros((2, 2), np.float32), np.eye(3), np.eye(4), np.ones((2, 2), bool)
+    )
+    assert points.shape == (0, 3)
+    assert points.dtype == np.float32
+
+
+def test_relative_direction_modes():
+    origin = np.array([0.0, 0.0, 0.0])
+    forward = np.array([0.0, 1.0, 0.0])
+    front_left = np.array([-1.0, 1.0, 0.0])
+    up = np.array([0.0, 0.0, 1.0])
+    assert (
+        geometric.answer_rel_direction(origin, forward, front_left, up, 2)
+        == "front-left"
+    )
+    assert (
+        geometric.answer_rel_direction(origin, forward, front_left, up, 2, "medium")
+        == "left"
+    )
+    assert geometric.answer_rel_direction(origin, origin, front_left, up, 2) is None
+
+
+def test_closest_distance_uses_point_cloud_distance():
+    first = [{"pts": np.array([[0.0, 0.0, 0.0]], np.float32), "n": 1}]
+    second = [{"pts": np.array([[0.0, 3.0, 4.0]], np.float32), "n": 1}]
+    assert geometric.answer_closest_distance(first, second) == pytest.approx(5.0)
+
+
+def test_robust_centroid_extent_returns_sorted_dimensions():
+    points = np.array(
+        [[x, y, z] for x in (-2.0, 2.0) for y in (-1.0, 1.0) for z in (-0.5, 0.5)],
+        np.float32,
+    )
+    centroid, longest, dimensions = geometric.robust_centroid_extent(points, up_axis=2)
+    np.testing.assert_allclose(centroid, [0.0, 0.0, 0.0])
+    assert longest > 3.0
+    assert np.all(dimensions[:-1] >= dimensions[1:])
+
+
+def test_depth_edges_handles_small_and_discontinuous_frames():
+    small = np.ones((5, 5), np.float32)
+    assert not geometric.depth_edges(small, np.ones_like(small, bool)).any()
+    depth = np.ones((20, 20), np.float32)
+    depth[:, 10:] = 10.0
+    edges = geometric.depth_edges(depth, np.ones_like(depth, bool))
+    assert edges[:, 9:11].any()

tests/test_encoder/test_geometric.py

@@ -0,0 +1,160 @@
+import json
+import re
+
+import numpy as np
+
+import geometric
+
+
+def test_dump_spatial_code(tmp_path):
+    path = tmp_path / "scene.json"
+    geometric.dump_spatial_code({"objects": {}, "appearance order": []}, path)
+    assert path.exists()
+    assert '"appearance order"' in path.read_text()
+
+
+def test_raw_bundle_dispatches_to_integrated_exact_path(monkeypatch):
+    expected = (
+        {
+            "objects": {},
+            "room": {"floor area": "0.0 square meters"},
+            "closest classes distance meters from": {},
+            "appearance order": [],
+        },
+        {},
+        {},
+        1,
+        np.array([0, 1, 0], dtype=np.float32),
+        0.0,
+    )
+    seen = {}
+
+    def fake(depth, intr, c2w, conf, ftimes, per):
+        seen.update(depth=depth, intr=intr, c2w=c2w, conf=conf, ftimes=ftimes, per=per)
+        return expected
+
+    monkeypatch.setattr(geometric, "build_spatial_code_raw", fake)
+    raw = {
+        "depth": np.ones((1, 2, 2), np.float32),
+        "intr": np.eye(3, dtype=np.float32)[None],
+        "c2w": np.eye(4, dtype=np.float32)[None],
+        "conf": None,
+        "ftimes": np.array([0.0], np.float32),
+        "per": {"chair": {}},
+    }
+    scene = {"raw_inputs": raw}
+    assert geometric.build_spatial_code(scene) is expected
+    assert seen == raw
+
+
+def test_exact_math_is_integrated_into_geometric_module():
+    assert callable(geometric.build_spatial_code_raw)
+    assert callable(geometric.dump_spatial_code)
+    assert not hasattr(geometric, "_reference")
+
+
+def test_position_reader_accepts_current_and_legacy_formatting():
+    assert geometric.pos3(
+        {
+            "position": {
+                "x coordinate": "1.25 meters",
+                "y coordinate": "-2.0 meters",
+                "height above floor": "0.5 meters",
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+    assert geometric.pos3(
+        {
+            "position": {
+                "floor_x_meters": 1.25,
+                "floor_y_meters": -2.0,
+                "height_above_floor_meters": 0.5,
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+
+
+def test_floor_level_v1_v2_math_is_shared(monkeypatch):
+    points = np.array([[0, 0, z] for z in [0, 0, 0, 1, 10]], np.float32)
+    gravity = np.array([0, 0, 1], np.float32)
+    monkeypatch.delenv("VSI_CODE_V2", raising=False)
+    v1 = geometric._floor_level(points, gravity)
+    monkeypatch.setenv("VSI_CODE_V2", "1")
+    v2 = geometric._floor_level(points, gravity)
+    assert 0 <= v1 < 0.2
+    assert v2 == 0.0
+
+
+METERS = re.compile(r"^-?\d+(?:\.\d+)? meters$")
+SQUARE_METERS = re.compile(r"^\d+(?:\.\d+)? square meters$")
+
+
+def _schema_instance(x, y, z, size, first_time=0.0):
+    pts = np.array(
+        [
+            [x - size / 2, y, z],
+            [x + size / 2, y, z],
+            [x, y - size / 2, z],
+            [x, y + size / 2, z],
+        ],
+        dtype=np.float32,
+    )
+    return {
+        "pts": pts,
+        "best_pts": pts,
+        "n": len(pts),
+        "nframes": 1,
+        "first_time": first_time,
+        "frames": {0},
+    }
+
+
+def _schema_scene():
+    chair = _schema_instance(0.0, 0.0, 0.5, 0.8, first_time=0.0)
+    table = _schema_instance(1.0, 0.0, 0.7, 1.2, first_time=1.0)
+    floor = np.array(
+        [[x, y, 0.0] for x in np.linspace(-1, 2, 5) for y in np.linspace(-1, 1, 5)],
+        dtype=np.float32,
+    )
+    return {
+        "instances": {"chair": [chair], "table": [table]},
+        "stats": {"chair": {"peak": 1}, "table": {"peak": 3}},
+        "scene_pts": np.concatenate([chair["pts"], table["pts"], floor], axis=0),
+        "cameras": None,
+    }
+
+
+def test_spatial_code_matches_reference_schema():
+    code, *_ = geometric.build_spatial_code(_schema_scene())
+    assert list(code) == [
+        "objects",
+        "room",
+        "closest classes distance meters from",
+        "appearance order",
+    ]
+    assert code["appearance order"] == ["chair", "table"]
+    assert SQUARE_METERS.match(code["room"]["floor area"])
+    for class_data in code["objects"].values():
+        assert set(class_data) == {"count", "instances"}
+        assert class_data["count"] == len(class_data["instances"])
+        for instance in class_data["instances"]:
+            assert set(instance) == {"position", "longest dimension"}
+            assert set(instance["position"]) == {
+                "x coordinate",
+                "y coordinate",
+                "height above floor",
+            }
+            assert all(METERS.match(value) for value in instance["position"].values())
+            assert METERS.match(instance["longest dimension"])
+    assert code["objects"]["table"]["count"] == 1
+    chair_to_table = code["closest classes distance meters from"]["chair"]["table"]
+    assert set(chair_to_table) == {"distance", "closeness rank"}
+    assert METERS.match(chair_to_table["distance"])
+    assert chair_to_table["closeness rank"] == 1
+
+
+def test_dumped_json_preserves_schema(tmp_path):
+    code, *_ = geometric.build_spatial_code(_schema_scene())
+    path = tmp_path / "scene.json"
+    geometric.dump_spatial_code(code, path)
+    assert json.loads(path.read_text()) == code

tests/test_encoder/test_launch.py

@@ -0,0 +1,49 @@
+import json
+import sys
+
+import pytest
+
+from encoder import config
+from encoder import launch
+
+
+def test_scenes_deduplicates_manifest_in_order(tmp_path, monkeypatch):
+    manifest = tmp_path / "test.jsonl"
+    manifest.write_text(
+        "\n".join(json.dumps({"scene_name": scene}) for scene in ("s1", "s2", "s1"))
+    )
+    monkeypatch.setattr(config, "JSONL", manifest)
+    assert launch._scenes() == ["s1", "s2"]
+
+
+def test_visible_gpus_uses_environment(monkeypatch):
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "2, 4, -1")
+    assert launch._visible_gpus() == ["2", "4"]
+
+
+def test_visible_gpus_falls_back_to_nvidia_smi(monkeypatch):
+    monkeypatch.delenv("CUDA_VISIBLE_DEVICES", raising=False)
+    monkeypatch.setattr(
+        launch.subprocess, "check_output", lambda *args, **kwargs: "0\n1\n"
+    )
+    assert launch._visible_gpus() == ["0", "1"]
+
+
+def test_main_skips_existing_spatial_codes(tmp_path, monkeypatch, capsys):
+    manifest = tmp_path / "test.jsonl"
+    manifest.write_text('{"scene_name": "s1"}\n')
+    codes = tmp_path / "codes"
+    (codes / "segvggt").mkdir(parents=True)
+    (codes / "segvggt" / "s1.json").write_text("{}")
+    monkeypatch.setattr(config, "JSONL", manifest)
+    monkeypatch.setattr(config, "CODES_ROOT", codes)
+    monkeypatch.setattr(sys, "argv", ["launch.py"])
+    monkeypatch.setattr(
+        launch.mp, "get_context", lambda *args: pytest.fail("workers should not start")
+    )
+
+    launch.main()
+
+    output = capsys.readouterr().out
+    assert "s1: skipped" in output
+    assert "DONE: 1 ok, 0 failed" in output

tests/test_encoder/test_render.py

@@ -0,0 +1,37 @@
+import json
+
+from encoder import config
+from encoder import render
+
+
+def test_build_spatial_code_uses_cached_geometry(monkeypatch):
+    geometry = {"instances": {}}
+    code = {"objects": {}}
+    monkeypatch.setattr(
+        render.perceive,
+        "cache_or_load",
+        lambda *args, **kwargs: (geometry, "loaded"),
+    )
+    monkeypatch.setattr(
+        render.geometry_math,
+        "build_spatial_code",
+        lambda value: (code, None),
+    )
+    assert render.build_spatial_code_for("abc", "segvggt") == (code, "loaded")
+
+
+def test_write_spatial_code_uses_scene_json(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "spatial codes")
+    monkeypatch.setattr(
+        render,
+        "build_spatial_code_for",
+        lambda *args, **kwargs: ({"objects": {}}, "loaded"),
+    )
+
+    _, how, path = render.write_spatial_code_for("abc", "segvggt")
+
+    assert how == "loaded"
+    assert path == str(tmp_path / "spatial codes" / "segvggt" / "abc.json")
+    assert json.loads(
+        (tmp_path / "spatial codes" / "segvggt" / "abc.json").read_text()
+    ) == {"objects": {}}

tests/test_encoder/test_run.py

@@ -0,0 +1,39 @@
+import gzip
+import pickle
+
+from encoder import adapters
+from encoder import config
+from encoder import run
+
+
+def _geometry():
+    return {
+        "instances": {"chair": [{"pts": [[0, 0, 0]], "best_pts": [[0, 0, 0]]}]},
+        "stats": {"chair": {"raw": 1, "merged": 1, "peak": 1}},
+        "scene_pts": [[0, 0, 0]],
+        "cameras": None,
+    }
+
+
+def test_cache_or_load_reads_flat_cache(tmp_path, monkeypatch):
+    path = tmp_path / "caches" / "segvggt" / "s1.pkl.gz"
+    path.parent.mkdir(parents=True)
+    with gzip.open(path, "wb") as cache:
+        pickle.dump(_geometry(), cache)
+    monkeypatch.setattr(config, "CACHE_ROOT", tmp_path / "caches")
+
+    result, how = run.cache_or_load("s1", "segvggt")
+
+    assert how == "loaded"
+    assert "chair" in result["instances"]
+
+
+def test_cache_or_load_builds_and_writes_cache(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CACHE_ROOT", tmp_path / "caches")
+    monkeypatch.setitem(adapters.RAW_ADAPTERS, "fake", lambda **kwargs: _geometry())
+
+    result, how = run.cache_or_load("s1", "fake")
+
+    assert how == "built"
+    assert result["instances"]["chair"][0]["n"] == 1
+    assert (tmp_path / "caches" / "fake" / "s1.pkl.gz").is_file()

tests/test_inference/conftest.py

@@ -0,0 +1,13 @@
+"""Shared import setup for inference tests."""
+
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+for path in (ROOT, ROOT / "encoder"):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+
+def pytest_configure(config):
+    config.option.importmode = "importlib"

tests/test_inference/test_adapters.py

@@ -0,0 +1,198 @@
+import pickle
+import sys
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from inference import adapters
+
+
+def test_load_model_validates_repository_and_checkpoint(tmp_path):
+    adapter = adapters.SegVGGTAdapter(model_root=tmp_path / "missing")
+    with pytest.raises(FileNotFoundError, match="repository not found"):
+        adapter.load_model("cpu")
+    model_root = tmp_path / "model"
+    model_root.mkdir()
+    adapter = adapters.SegVGGTAdapter(
+        model_root=model_root, checkpoint=tmp_path / "missing.pt"
+    )
+    with pytest.raises(FileNotFoundError, match="checkpoint not found"):
+        adapter.load_model("cpu")
+
+
+def test_run_scene_requires_loaded_model(tmp_path):
+    adapter = adapters.SegVGGTAdapter()
+    with pytest.raises(RuntimeError, match=r"load_model\(\)"):
+        adapter.run_scene("video.mp4", tmp_path / "scene.pt", 1)
+
+
+def test_read_video_rejects_unopenable_file():
+    with pytest.raises(RuntimeError, match="cannot open video"):
+        adapters.SegVGGTAdapter._read_video("/missing/video.mp4", 1)
+
+
+def test_run_scene_preserves_raw_dtypes_and_encoder_geometry(tmp_path, monkeypatch):
+    torch = pytest.importorskip("torch")
+    adapter = adapters.SegVGGTAdapter()
+    adapter.device = torch.device("cpu")
+    adapter.dtype = torch.bfloat16
+    frames = np.zeros((1, 2, 2, 3), np.uint8)
+    monkeypatch.setattr(
+        adapter,
+        "_read_video",
+        lambda path, count: (frames, np.array([0.25], np.float32)),
+    )
+
+    class Model:
+        def __call__(self, images):
+            return {
+                "instance_maps": torch.zeros((1, 2, 1, 2, 2), dtype=torch.bfloat16),
+                "instance_labels": torch.zeros((1, 2, 3)),
+                "depth": torch.ones((1, 1, 2, 2)),
+                "pose_enc": torch.zeros((1, 1, 4)),
+            }
+
+    adapter.model = Model()
+    adapter.runtime = torch
+    output = tmp_path / "nested" / "scene.pt"
+    adapter.run_scene("video.mp4", output, 1)
+
+    assert output.is_file()
+    assert not output.with_suffix(".pt.tmp").exists()
+    cache = torch.load(output, map_location="cpu", weights_only=False)
+    assert set(cache) == {
+        "instance_maps",
+        "instance_labels",
+        "depth",
+        "pose_enc",
+    }
+    assert cache["instance_maps"].dtype == torch.bfloat16
+    assert cache["depth"].dtype == torch.float32
+    assert all(value.device.type == "cpu" for value in cache.values())
+
+
+def test_da3_preserves_native_prediction_object(tmp_path, monkeypatch):
+    adapter = adapters.DepthAnything3Adapter()
+    prediction = SimpleNamespace(
+        depth=np.ones((2, 3, 4), dtype=np.float32),
+        conf=np.ones((2, 3, 4), dtype=np.float16),
+        is_metric=True,
+    )
+
+    class Model:
+        def inference(self, images, export_dir):
+            assert images == ["frame"]
+            assert export_dir is None
+            return prediction
+
+    adapter.model = Model()
+    monkeypatch.setattr(adapter, "_read_video", lambda path, count: ["frame"])
+    output = tmp_path / "depth-anything-3" / "scene.pkl"
+    adapter.run_scene("video.mp4", output, 1)
+
+    with output.open("rb") as stream:
+        restored = pickle.load(stream)
+    assert vars(restored).keys() == vars(prediction).keys()
+    assert restored.depth.dtype == np.float32
+    assert restored.conf.dtype == np.float16
+    assert restored.is_metric is True
+    assert not output.with_suffix(".pkl.tmp").exists()
+
+
+def test_sam3_preserves_independent_image_responses_without_tracking(
+    tmp_path, monkeypatch
+):
+    states = []
+    monkeypatch.setitem(
+        sys.modules,
+        "PIL",
+        SimpleNamespace(Image=SimpleNamespace(fromarray=lambda frame: frame)),
+    )
+
+    class Processor:
+        def set_image(self, image):
+            state = {"frame": len(states), "shape": image.shape}
+            states.append(state)
+            return state
+
+        def set_text_prompt(self, state, prompt):
+            assert prompt == "chair"
+            return {"state": state, "masks": np.ones((1, 2, 2), np.float32)}
+
+    class InferenceMode:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+    class Runtime:
+        @staticmethod
+        def inference_mode():
+            return InferenceMode()
+
+        @staticmethod
+        def save(value, path):
+            with open(path, "wb") as stream:
+                pickle.dump(value, stream)
+
+    adapter = adapters.SAM3Adapter(prompt="chair")
+    adapter.model = object()
+    adapter.processor = Processor()
+    adapter.runtime = Runtime()
+    monkeypatch.setattr(
+        adapters,
+        "_sample_video_frames",
+        lambda path, count: (
+            np.stack(
+                [
+                    np.zeros((2, 3, 3), np.uint8),
+                    np.ones((2, 3, 3), np.uint8),
+                ]
+            ),
+            np.array([0.0, 1.0], np.float32),
+        ),
+    )
+    output = tmp_path / "sam3" / "scene.pt"
+    adapter.run_scene("video.mp4", output, 2)
+
+    with output.open("rb") as stream:
+        restored = pickle.load(stream)
+    assert [response["state"]["frame"] for response in restored] == [0, 1]
+    assert all(response["masks"].dtype == np.float32 for response in restored)
+    assert len(states) == 2
+    assert not output.with_suffix(".pt.tmp").exists()
+
+
+def test_combined_adapter_gives_both_models_the_same_decoded_frames(monkeypatch):
+    calls = []
+    frames = np.arange(24, dtype=np.uint8).reshape(2, 2, 2, 3)
+    monkeypatch.setattr(
+        adapters,
+        "_sample_video_frames",
+        lambda path, count: (frames, np.array([0.0, 1.0], np.float32)),
+    )
+
+    class Child:
+        def __init__(self, name):
+            self.name = name
+
+        def run_frames(self, received_frames, output_path):
+            calls.append((self.name, received_frames, output_path))
+
+    adapter = adapters.SAM3DepthAnything3Adapter()
+    adapter.sam3 = Child("sam3")
+    adapter.depth_anything_3 = Child("depth-anything-3")
+    outputs = {
+        "sam3": "/root/data/caches/sam3/scene.pt",
+        "depth-anything-3": "/root/data/caches/depth-anything-3/scene.pkl",
+    }
+    adapter.run_scene("/videos/scene.mp4", outputs, 32)
+
+    assert [(name, path) for name, _, path in calls] == [
+        ("sam3", outputs["sam3"]),
+        ("depth-anything-3", outputs["depth-anything-3"]),
+    ]
+    assert calls[0][1] is calls[1][1]
+    assert calls[0][1] is frames

tests/test_inference/test_inference.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+import pytest
+
+from inference import adapters
+from inference import launch
+from inference import run
+
+
+class FakeAdapter:
+    model = object()
+
+    def __init__(self):
+        self.calls = []
+
+    def run_scene(self, video_path, output_path, frame_count):
+        self.calls.append((video_path, output_path, frame_count))
+        path = Path(output_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.touch()
+
+
+def test_adapter_registry():
+    assert adapters.available_models() == (
+        "depth-anything-3",
+        "sam3",
+        "sam3+depth-anything-3",
+        "segvggt",
+    )
+    assert isinstance(
+        adapters.get_adapter("depth-anything-3"),
+        adapters.DepthAnything3Adapter,
+    )
+    assert isinstance(adapters.get_adapter("sam3"), adapters.SAM3Adapter)
+    assert isinstance(
+        adapters.get_adapter("sam3+depth-anything-3"),
+        adapters.SAM3DepthAnything3Adapter,
+    )
+    assert isinstance(adapters.get_adapter("segvggt"), adapters.SegVGGTAdapter)
+    with pytest.raises(KeyError, match="unknown inference model"):
+        adapters.get_adapter("unknown")
+
+
+def test_local_model_roots_are_exact(monkeypatch):
+    for variable in ("VSI_SEGVGGT_ROOT", "VSI_SAM3_ROOT", "VSI_DA3_ROOT"):
+        monkeypatch.delenv(variable, raising=False)
+    assert adapters.SegVGGTAdapter().model_root == Path("/root/models/SegVGGT")
+    assert adapters.SAM3Adapter().model_root == Path("/root/models/sam3")
+    assert adapters.DepthAnything3Adapter().model_root == Path(
+        "/root/models/depth-anything-3"
+    )
+
+
+def test_native_output_paths(tmp_path, monkeypatch):
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
+    assert run.output_path("scene1", "depth-anything-3") == str(
+        tmp_path / "depth-anything-3" / "scene1.pkl"
+    )
+    assert run.output_path("scene1", "sam3") == str(tmp_path / "sam3" / "scene1.pt")
+    assert run.output_path("scene1", "sam3+depth-anything-3") == {
+        "sam3": str(tmp_path / "sam3" / "scene1.pt"),
+        "depth-anything-3": str(tmp_path / "depth-anything-3" / "scene1.pkl"),
+    }
+
+
+def test_run_scene_builds_then_skips(tmp_path, monkeypatch):
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
+    monkeypatch.setattr(
+        run.inference_config, "video_path", lambda scene: f"/videos/{scene}.mp4"
+    )
+    adapter = FakeAdapter()
+    assert run.run_scene("scene1", adapter=adapter) == (
+        "built",
+        str(tmp_path / "segvggt" / "scene1.pt"),
+    )
+    assert run.run_scene("scene1", adapter=adapter)[0] == "skipped"
+    assert len(adapter.calls) == 1
+
+
+def test_scenes_deduplicates_manifest(tmp_path, monkeypatch):
+    manifest = tmp_path / "test.jsonl"
+    manifest.write_text(
+        '{"scene_name": "s1"}\n{"scene_name": "s2"}\n{"scene_name": "s1"}\n'
+    )
+    monkeypatch.setattr(launch.inference_config, "JSONL", manifest)
+    assert launch.scenes() == ["s1", "s2"]
+
+
+def test_visible_gpus_uses_environment(monkeypatch):
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "2, 4, -1")
+    assert launch.visible_gpus() == ["2", "4"]

tests/test_inference/test_launch.py

@@ -0,0 +1,130 @@
+from queue import Queue
+from types import SimpleNamespace
+import sys
+
+import pytest
+
+from inference import launch
+from inference import run
+
+
+class FakeAdapter:
+    def __init__(self, load_error=None):
+        self.load_error = load_error
+        self.load_calls = []
+
+    def load_model(self, device):
+        self.load_calls.append(device)
+        if self.load_error:
+            raise self.load_error
+
+
+def _queues(*scenes):
+    tasks, results = Queue(), Queue()
+    for scene in scenes:
+        tasks.put(scene)
+    tasks.put(None)
+    return tasks, results
+
+
+def test_worker_loads_adapter_once_and_reuses_it(monkeypatch):
+    adapter = FakeAdapter()
+    calls = []
+    fake_run = SimpleNamespace(
+        run_scene=lambda scene, model, frames, rebuild, adapter: (
+            calls.append(scene) or ("built", f"/{scene}.npz")
+        )
+    )
+    monkeypatch.setattr(launch.adapters, "get_adapter", lambda model: adapter)
+    monkeypatch.setattr(launch, "_load_run_module", lambda: fake_run)
+    tasks, results = _queues("s1", "s2")
+
+    launch._worker(tasks, results, "segvggt", 32, False, "3", 2)
+
+    assert adapter.load_calls == ["cuda:0"]
+    assert calls == ["s1", "s2"]
+    assert results.get() == ("s1", True, "built -> /s1.npz")
+    assert results.get() == ("s2", True, "built -> /s2.npz")
+
+
+def test_worker_reports_model_load_failure_for_every_scene(monkeypatch):
+    adapter = FakeAdapter(RuntimeError("load failed"))
+    monkeypatch.setattr(launch.adapters, "get_adapter", lambda model: adapter)
+    monkeypatch.setattr(launch, "_load_run_module", lambda: SimpleNamespace())
+    tasks, results = _queues("s1", "s2")
+
+    launch._worker(tasks, results, "segvggt", 32, False, None, 1)
+
+    for expected in ("s1", "s2"):
+        scene, ok, detail = results.get()
+        assert scene == expected and not ok
+        assert "load failed" in detail
+    assert adapter.load_calls == ["cpu"]
+
+
+def test_worker_reports_scene_failure_and_continues(monkeypatch):
+    adapter = FakeAdapter()
+
+    def run_scene(scene, *args, **kwargs):
+        if scene == "bad":
+            raise ValueError("broken scene")
+        return "built", f"/{scene}.npz"
+
+    monkeypatch.setattr(launch.adapters, "get_adapter", lambda model: adapter)
+    monkeypatch.setattr(
+        launch, "_load_run_module", lambda: SimpleNamespace(run_scene=run_scene)
+    )
+    tasks, results = _queues("bad", "good")
+
+    launch._worker(tasks, results, "segvggt", 32, False, None, 1)
+
+    first, second = results.get(), results.get()
+    assert first[0:2] == ("bad", False) and "broken scene" in first[2]
+    assert second == ("good", True, "built -> /good.npz")
+
+
+def test_run_scene_rebuild_overwrites_existing_cache(tmp_path, monkeypatch):
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
+    monkeypatch.setattr(
+        run.inference_config, "video_path", lambda scene: f"/{scene}.mp4"
+    )
+    destination = tmp_path / "segvggt" / "s1.pt"
+    destination.parent.mkdir()
+    destination.write_bytes(b"old")
+    calls = []
+    adapter = SimpleNamespace(
+        run_scene=lambda *args: calls.append(args) or destination.write_bytes(b"new")
+    )
+
+    status, _ = run.run_scene("s1", rebuild=True, adapter=adapter)
+
+    assert status == "built"
+    assert destination.read_bytes() == b"new"
+    assert len(calls) == 1
+
+
+def test_visible_gpus_falls_back_to_nvidia_smi(monkeypatch):
+    monkeypatch.delenv("CUDA_VISIBLE_DEVICES", raising=False)
+    monkeypatch.setattr(
+        launch.subprocess, "check_output", lambda *args, **kwargs: "0\n2\n"
+    )
+    assert launch.visible_gpus() == ["0", "2"]
+
+
+def test_launch_main_skips_all_existing_caches(tmp_path, monkeypatch, capsys):
+    cache = tmp_path / "s1.npz"
+    cache.touch()
+    monkeypatch.setattr(launch, "scenes", lambda: ["s1"])
+    monkeypatch.setattr(
+        launch,
+        "_load_run_module",
+        lambda: SimpleNamespace(output_paths=lambda *args: {"segvggt": str(cache)}),
+    )
+    monkeypatch.setattr(sys, "argv", ["launch.py"])
+    monkeypatch.setattr(
+        launch.mp, "get_context", lambda *args: pytest.fail("workers should not start")
+    )
+
+    launch.main()
+
+    assert "DONE: 0 built, 1 skipped, 0 failed" in capsys.readouterr().out

tests/test_inference/test_run.py

@@ -0,0 +1,41 @@
+"""Optional real-model validation; enable with VSI_RUN_GPU_TESTS=1."""
+
+import json
+import os
+
+import pytest
+
+from inference import adapters
+from inference import run
+
+
+@pytest.mark.skipif(
+    os.environ.get("VSI_RUN_GPU_TESTS") != "1",
+    reason="set VSI_RUN_GPU_TESTS=1 to run real SegVGGT inference",
+)
+def test_real_segvggt_scene_preserves_native_prediction_dictionary(tmp_path):
+    torch = pytest.importorskip("torch")
+    with open(run.inference_config.JSONL) as manifest:
+        scene = str(json.loads(next(manifest))["scene_name"])
+    adapter = adapters.get_adapter("segvggt")
+    adapter.load_model("cuda:0")
+    output = tmp_path / f"{scene}.pt"
+    adapter.run_scene(
+        run.inference_config.video_path(scene),
+        str(output),
+        run.inference_config.FRAMES_PER_VIDEO,
+    )
+    cache = torch.load(output, map_location="cpu", weights_only=False)
+    assert isinstance(cache, dict)
+    assert {
+        "pose_enc",
+        "depth",
+        "world_points",
+        "instance_maps",
+        "instance_labels",
+    }.issubset(cache)
+    assert all(
+        value.device.type == "cpu"
+        for value in cache.values()
+        if isinstance(value, torch.Tensor)
+    )

tests/test_symbolic/conftest.py

@@ -0,0 +1,78 @@
+"""Shared import setup and fixtures for symbolic tests."""
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+import sys
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SYMBOLIC_ROOT = ROOT / "symbolic"
+ENCODER_ROOT = ROOT / "encoder"
+
+
+def pytest_configure(config):
+    config.option.importmode = "importlib"
+
+
+if str(SYMBOLIC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SYMBOLIC_ROOT))
+sys.modules.setdefault("utils", ModuleType("utils"))
+
+launch_spec = importlib.util.spec_from_file_location(
+    "symbolic_launch_tests", SYMBOLIC_ROOT / "launch.py"
+)
+symbolic_launch = importlib.util.module_from_spec(launch_spec)
+sys.modules["symbolic_launch_tests"] = symbolic_launch
+launch_spec.loader.exec_module(symbolic_launch)
+sys.modules["symbolic_run_tests"] = symbolic_launch.symbolic_run
+sys.modules["symbolic_solver_tests"] = symbolic_launch.symbolic_run.sym
+
+if str(SYMBOLIC_ROOT) in sys.path:
+    sys.path.remove(str(SYMBOLIC_ROOT))
+if str(ENCODER_ROOT) not in sys.path:
+    sys.path.insert(0, str(ENCODER_ROOT))
+
+
+@pytest.fixture
+def spatial_code():
+    def object_record(x, y, size="1.0 meters", count=1):
+        return {
+            "count": count,
+            "instances": [
+                {
+                    "position": {
+                        "x coordinate": f"{x} meters",
+                        "y coordinate": f"{y} meters",
+                        "height above floor": "0.5 meters",
+                    },
+                    "longest dimension": size,
+                }
+            ],
+        }
+
+    return {
+        "objects": {
+            "chair": object_record(0, 0, "0.8 meters", count=2),
+            "table": object_record(0, 1, "1.2 meters"),
+            "lamp": object_record(-1, 1, "0.4 meters"),
+            "sofa": object_record(1, 1, "2.0 meters"),
+        },
+        "room": {"floor area": "12.5 square meters"},
+        "appearance order": ["chair", "table", "lamp", "sofa"],
+        "closest classes distance meters from": {
+            "chair": {
+                "table": {"distance": "1.0 meters", "closeness rank": 1},
+                "lamp": {"distance": "1.4 meters", "closeness rank": 2},
+                "sofa": {"distance": "1.5 meters", "closeness rank": 3},
+            },
+            "table": {
+                "chair": {"distance": "1.0 meters", "closeness rank": 1},
+                "lamp": {"distance": "0.8 meters", "closeness rank": 2},
+                "sofa": {"distance": "0.9 meters", "closeness rank": 3},
+            },
+            "lamp": {"table": {"distance": "0.8 meters", "closeness rank": 1}},
+            "sofa": {"table": {"distance": "0.9 meters", "closeness rank": 1}},
+        },
+    }

tests/test_symbolic/test_launch.py

@@ -0,0 +1,61 @@
+import json
+
+import pytest
+
+import symbolic_launch_tests as launch
+
+
+def _question(question_type, answer, ground_truth, question, options=None):
+    return {
+        "question_type": question_type,
+        "engine_answer": answer,
+        "ground_truth": ground_truth,
+        "question": question,
+        "options": options,
+    }
+
+
+def test_scenes_with_spatial_codes_returns_sorted_stems(tmp_path, monkeypatch):
+    monkeypatch.setattr(launch.symbolic_run, "SPATIAL_CODES_DIR", str(tmp_path))
+    for name in ("scene2.json", "scene1.json"):
+        (tmp_path / name).write_text(json.dumps({}))
+    assert launch.scenes_with_spatial_codes() == ["scene1", "scene2"]
+
+
+def test_error_analysis_summarizes_numeric_errors():
+    questions = [
+        _question("object_counting", 3, "2", "How many chair(s) are in this room?"),
+        _question("object_counting", 1, "2", "How many table(s) are in this room?"),
+        _question("object_counting", None, "1", "How many lamp(s) are in this room?"),
+    ]
+    result = launch.error_analysis({"scene1": (questions, {})}, "object_counting")
+    assert result["n"] == 3
+    assert result["n_unanswered"] == 1
+    assert result["mean_absolute_error"] == 1.0
+    assert result["overcounts"] == 1
+    assert result["undercounts"] == 1
+    assert [item["class"] for item in result["by_class"]] == ["chair", "table"]
+
+
+def test_error_analysis_rejects_non_numeric_question_type():
+    with pytest.raises(ValueError, match="only supports"):
+        launch.error_analysis({}, "route_planning")
+
+
+def test_mca_answer_breakdown_distinguishes_outcomes():
+    options = ["A. chair, table, lamp", "B. table, chair, lamp"]
+    questions = [
+        _question("obj_appearance_order", "A", "A", "question", options),
+        _question("obj_appearance_order", "B", "A", "question", options),
+        _question("obj_appearance_order", None, "A", "question", options),
+    ]
+    result = launch.mca_answer_breakdown(
+        {"scene1": (questions, {})}, "obj_appearance_order"
+    )
+    assert result == {
+        "n": 3,
+        "n_unanswered": 1,
+        "n_wrong": 1,
+        "n_correct": 1,
+        "mean_swap_distance": 1.0,
+    }

tests/test_symbolic/test_run.py

@@ -0,0 +1,73 @@
+import json
+
+import pytest
+
+import symbolic_run_tests as symbolic_run
+
+
+def test_find_workspace_root_uses_spatial_codes_folder(tmp_path):
+    start = tmp_path / "project" / "symbolic"
+    (tmp_path / "project" / "data" / "spatial codes" / "sam3+depth-anything-3").mkdir(
+        parents=True
+    )
+    start.mkdir()
+    assert symbolic_run._find_workspace_root(start) == str(tmp_path / "project")
+
+
+def test_fetch_spatial_code_reads_flat_json(tmp_path, monkeypatch, spatial_code):
+    monkeypatch.setattr(symbolic_run, "SPATIAL_CODES_DIR", str(tmp_path))
+    (tmp_path / "scene1.json").write_text(json.dumps(spatial_code))
+    assert symbolic_run.spatial_code_path("scene1") == str(tmp_path / "scene1.json")
+    assert symbolic_run.fetch_spatial_code("scene1") == spatial_code
+
+
+def test_select_model_reads_fusion_subfolder(tmp_path, monkeypatch):
+    monkeypatch.setattr(symbolic_run, "SPATIAL_CODES_ROOT", str(tmp_path))
+    monkeypatch.setattr(symbolic_run, "SPATIAL_CODES_DIR_OVERRIDE", None)
+    assert symbolic_run.select_spatial_codes_model("sam3+depth-anything-3") == str(
+        tmp_path / "sam3+depth-anything-3"
+    )
+
+
+def test_fetch_spatial_code_reports_missing_file(tmp_path, monkeypatch):
+    monkeypatch.setattr(symbolic_run, "SPATIAL_CODES_DIR", str(tmp_path))
+    with pytest.raises(FileNotFoundError, match="no spatial code found"):
+        symbolic_run.fetch_spatial_code("missing")
+
+
+def test_real_questions_for_scene_filters_jsonl(tmp_path):
+    path = tmp_path / "test.jsonl"
+    rows = [
+        {"scene_name": "scene1", "id": "q1"},
+        {"scene_name": "scene2", "id": "q2"},
+        {"scene_name": "scene1", "id": "q3"},
+    ]
+    path.write_text("\n".join(json.dumps(row) for row in rows))
+    assert [
+        row["id"] for row in symbolic_run.real_questions_for_scene("scene1", path)
+    ] == [
+        "q1",
+        "q3",
+    ]
+
+
+def test_write_scene_results_uses_one_file_per_question(tmp_path, spatial_code):
+    question = {
+        "question_id": "q1",
+        "dataset": "scannet",
+        "question_type": "object_counting",
+        "question": "How many chair(s) are in this room?",
+        "options": None,
+        "engine_answer": 2,
+        "ground_truth": "2",
+        "score": 1.0,
+    }
+    paths = symbolic_run.write_scene_results(
+        "scene1", [question], {"accuracy": 1.0}, spatial_code, tmp_path
+    )
+    record = json.loads((tmp_path / "scene1" / "q1.json").read_text())
+    aggregate = json.loads((tmp_path / "scene1" / "_aggregate.json").read_text())
+    assert len(paths) == 2
+    assert record["answer_given"] == "2"
+    assert record["model"] == "symbolic"
+    assert aggregate == {"scene_id": "scene1", "aggregate": {"accuracy": 1.0}}

tests/test_symbolic/test_solver.py

@@ -0,0 +1,121 @@
+import pytest
+
+import symbolic_solver_tests as solver
+
+
+def test_unit_parsers_accept_strings_and_numbers():
+    assert solver._parse_meters("-1.25 meters") == -1.25
+    assert solver._parse_square_meters("12.5 square meters") == 12.5
+    assert solver._parse_meters(3) == 3.0
+    with pytest.raises(ValueError, match="could not parse"):
+        solver._parse_meters("unknown")
+
+
+def test_direct_numeric_answers(spatial_code):
+    assert (
+        solver.answer(
+            "object_counting", "How many chair(s) are in this room?", None, spatial_code
+        )
+        == 2
+    )
+    assert (
+        solver.answer(
+            "object_size_estimation",
+            "What is the longest dimension of the table, measured in centimeters?",
+            None,
+            spatial_code,
+        )
+        == 120.0
+    )
+    assert (
+        solver.answer(
+            "room_size_estimation", "What is the size of this room?", None, spatial_code
+        )
+        == 12.5
+    )
+    assert (
+        solver.answer(
+            "object_abs_distance",
+            "What is the distance between the chair and the table (in meters)?",
+            None,
+            spatial_code,
+        )
+        == 1.0
+    )
+
+
+def test_multiple_choice_distance_and_order_answers(spatial_code):
+    assert (
+        solver.answer(
+            "object_rel_distance",
+            "Which of these objects is closest to the table?",
+            ["A. sofa", "B. lamp", "C. chair"],
+            spatial_code,
+        )
+        == "B"
+    )
+    assert (
+        solver.answer(
+            "obj_appearance_order",
+            "What is the first-time appearance order of the categories?",
+            ["A. table, chair, lamp", "B. chair, table, lamp"],
+            spatial_code,
+        )
+        == "B"
+    )
+
+
+def test_direction_answers_use_floor_coordinates(spatial_code):
+    question = (
+        "If I am standing by the chair and facing the table, is the lamp to my left?"
+    )
+    assert (
+        solver.answer(
+            "object_rel_direction_hard",
+            question,
+            ["A. front-left", "B. front-right", "C. back-left", "D. back-right"],
+            spatial_code,
+        )
+        == "A"
+    )
+    assert (
+        solver.answer(
+            "object_rel_direction_easy",
+            question,
+            ["A. left", "B. right"],
+            spatial_code,
+        )
+        == "A"
+    )
+
+
+def test_route_planning_chains_turns(spatial_code):
+    question = (
+        "You are a robot beginning at the chair facing the table. Actions: "
+        "1. Go forward until the table 2. [please fill in] "
+        "3. Go forward until the lamp."
+    )
+    assert (
+        solver.answer(
+            "route_planning",
+            question,
+            ["A. Turn Left", "B. Turn Right", "C. Turn Back"],
+            spatial_code,
+        )
+        == "A"
+    )
+
+
+def test_dispatch_returns_none_for_unknown_or_missing_data(spatial_code):
+    assert solver.answer("unknown", "question", None, spatial_code) is None
+    assert (
+        solver.answer(
+            "object_counting",
+            "How many cabinet(s) are in this room?",
+            None,
+            spatial_code,
+        )
+        == 0
+    )
+    assert solver.pairwise_swap_distance(["a", "b", "c"], ["b", "a", "c"]) == 1
+    assert solver.pairwise_swap_distance(["a"], ["b"]) is None

tests/test_symbolic/test_symbolic.py

@@ -0,0 +1,13 @@
+"""Folder-level contract tests for the symbolic package."""
+
+import symbolic_launch_tests as launch
+import symbolic_run_tests as run
+import symbolic_solver_tests as solver
+
+
+def test_symbolic_folder_modules_are_wired_together():
+    assert launch.symbolic_run is run
+    assert run.sym is solver
+    assert callable(run.score_scene)
+    assert callable(launch.run_all)
+    assert callable(solver.answer)