Upload workspace snapshot

README.md

@@ -157,6 +157,36 @@ Important files:
 - `encoder/launch.py`: CPU-parallel batch driver
 - `encoder/ground_truth.py`: ground-truth compact/explicit code builder
 
+### Experiments: Geometry Hypotheses
+
+```bash
+# List available hypothesis forks.
+python -m experiments.run --list
+
+# Build one hypothesis spatial code from existing caches only.
+python -m experiments.run SCENE --hypothesis "Compute Gravity Before Building Object Instances" --depth metric --tracking tracking --input uniform --frames 64 --format explicit
+
+# Batch all scenes with existing combined or native SAM3/DA3 caches.
+python -m experiments.launch --hypothesis "Compute Gravity Before Building Object Instances" --depth metric --tracking tracking --input uniform --frames 64 --format explicit
+
+# Evaluate generated experiment spatial codes with the symbolic scorer.
+python -m experiments.evaluate --hypothesis "Compute Gravity Before Building Object Instances" --depth metric --tracking tracking --input uniform --frames 64 --format explicit --quiet --errors
+```
+
+Files:
+
+- `experiments/__init__.py`: experiments package marker
+- `experiments/README.md`: experiment workflow notes
+- `experiments/EXPERIMENT FINDINGS.md`: single consolidated findings report
+- `experiments/hypotheses.md`: hypothesis index and notes
+- `experiments/config.py`: experiment-local path construction
+- `experiments/adapters.py`: build-call adapter for explicit and compact hypothesis forks
+- `experiments/loader.py`: dynamic loader for human-readable hypothesis filenames
+- `experiments/run.py`: one-scene cache-only hypothesis spatial-code builder
+- `experiments/launch.py`: batch launcher over scenes with existing caches
+- `experiments/evaluate.py`: symbolic evaluation of experiment spatial codes
+- `experiments/hypotheses/*.py`: standalone geometry hypothesis forks; each exposes `build_spatial_code()` and `dump_spatial_code()`
+
 ### Symbolic Solver
 
 ```bash
@@ -411,6 +441,8 @@ Files:
 | `README.md` | This documentation |
 | `setup.sh` | Environment, package, data, model, and validation setup |
 | `backup.py` | Hugging Face dataset backup utility |
+| `.gitattributes` | Git LFS attributes for large/binary artifact patterns |
+| `.gitignore` | Excludes generated caches, notebooks, envs, and result folders |
 | `selective_frame_counts.csv` | Static frame-count/reference data used by selection workflows |
 | `bundles/spatial-codes.tar.gz` | Packed spatial-code artifact used by setup sync |
 
@@ -644,6 +676,18 @@ The tests mirror source folders. They are written to run without real data, resu
 - `tests/test_encoder/test_render.py`
 - `tests/test_encoder/test_run.py`
 
+### `tests/test_experiments/`
+
+- `tests/test_experiments/__init__.py`
+- `tests/test_experiments/conftest.py`
+- `tests/test_experiments/test_config.py`
+- `tests/test_experiments/test_evaluate.py`
+- `tests/test_experiments/test_experiments.py`
+- `tests/test_experiments/test_hypotheses.py`
+- `tests/test_experiments/test_launch.py`
+- `tests/test_experiments/test_loader.py`
+- `tests/test_experiments/test_run.py`
+
 ### `tests/test_harness/`
 
 - `tests/test_harness/__init__.py`

experiments/hypotheses/Bridge Floor To Wall Grazing Gap.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1711,7 +1719,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1810,13 +1821,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1977,9 +1992,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2012,9 +2025,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Bridge Unobserved Floor With Room Scale Close.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1778,13 +1784,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1946,9 +1956,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1981,9 +1989,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV FloorClip 005.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV FloorClip 05.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV Grazing 3.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV Grazing 7.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV LenAxis 075.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.75) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.75)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV LenAxis 10.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 1.0) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 1.0)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV SOR 125.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/CV SOR 20.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Center Compact Boxes On Point Cloud Median.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1711,7 +1719,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1807,13 +1818,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1970,9 +1985,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2005,9 +2018,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Center Sigma 15.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1665,7 +1671,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     weights = np.sqrt(np.asarray(weights, np.float64))
     core_centers, core_dimensions, core_weights = centers, dimensions, weights
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1693,7 +1701,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
             full_dimensions = full_dimensions[consistent]
             weights = weights[consistent]
     box_center_local = np.array(
-        [_weighted_quantile(core_centers[:, axis], core_weights, 0.5) for axis in range(3)]
+        [
+            _weighted_quantile(core_centers[:, axis], core_weights, 0.5)
+            for axis in range(3)
+        ]
     )
     # Size each axis by a HIGH percentile (0.90) of the mutually-consistent observed extents,
     # not the 75th. A partial/occluded/foreshortened view of an object can only measure a
@@ -1738,7 +1749,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1837,13 +1851,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2006,9 +2024,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2041,9 +2057,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Center Sigma 25.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1665,7 +1671,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     weights = np.sqrt(np.asarray(weights, np.float64))
     core_centers, core_dimensions, core_weights = centers, dimensions, weights
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1693,7 +1701,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
             full_dimensions = full_dimensions[consistent]
             weights = weights[consistent]
     box_center_local = np.array(
-        [_weighted_quantile(core_centers[:, axis], core_weights, 0.5) for axis in range(3)]
+        [
+            _weighted_quantile(core_centers[:, axis], core_weights, 0.5)
+            for axis in range(3)
+        ]
     )
     # Size each axis by a HIGH percentile (0.90) of the mutually-consistent observed extents,
     # not the 75th. A partial/occluded/foreshortened view of an object can only measure a
@@ -1738,7 +1749,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1837,13 +1851,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2006,9 +2024,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2041,9 +2057,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Clean Box Points At Sixtieth Confidence.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -518,7 +522,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -574,7 +579,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -629,7 +635,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1230,7 +1237,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1612,15 +1620,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1671,7 +1677,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1718,7 +1726,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1814,13 +1825,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1977,9 +1992,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2012,9 +2025,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Clean Distance Path Keep Raw Size Extent.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1643,7 +1647,8 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         # extremes; cleaning only the distance path gives the distance gain without the size cost.
         raw_proj = (
             np.stack(
-                [observation @ u, observation @ v, observation @ g - floor_level], axis=1
+                [observation @ u, observation @ v, observation @ g - floor_level],
+                axis=1,
             )
             @ orientation.T
         )
@@ -1680,7 +1685,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1742,7 +1749,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1841,13 +1851,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2010,9 +2024,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2045,9 +2057,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Clean Distance Path Raw Size Select.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1643,7 +1647,8 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         # extremes; cleaning only the distance path gives the distance gain without the size cost.
         raw_proj = (
             np.stack(
-                [observation @ u, observation @ v, observation @ g - floor_level], axis=1
+                [observation @ u, observation @ v, observation @ g - floor_level],
+                axis=1,
             )
             @ orientation.T
         )
@@ -1680,7 +1685,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1742,7 +1749,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     # select the longest axis from the RAW full extent (size's own signal), NOT the cleaned
@@ -1845,13 +1855,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2014,9 +2028,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2049,9 +2061,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Clean Each Observation Before Extent Tight.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1659,7 +1663,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1675,7 +1681,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1737,7 +1745,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1836,13 +1847,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2005,9 +2020,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2040,9 +2053,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Clean Each Observation Before Extent.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1659,7 +1663,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1675,7 +1681,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1737,7 +1745,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1836,13 +1847,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2005,9 +2020,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2040,9 +2053,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Confidence Weighted Box Frames.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1226,7 +1233,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1606,15 +1614,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1658,9 +1662,15 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         _mc = 1.0
-        if _obs_conf is not None and _oi < len(_obs_conf) and _obs_conf[_oi] is not None:
+        if (
+            _obs_conf is not None
+            and _oi < len(_obs_conf)
+            and _obs_conf[_oi] is not None
+        ):
             _cf = np.asarray(_obs_conf[_oi], np.float64)
             _cf = _cf[finite] if len(_cf) == len(finite) else _cf
             if len(_cf):
@@ -1680,7 +1690,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1742,7 +1754,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1841,13 +1856,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2010,9 +2029,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2045,9 +2062,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Confidence Weighted Percentile Short Axes.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1226,7 +1233,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1603,7 +1611,8 @@ def _weighted_quantile(values, weights, quantile):
 
 def _weighted_percentile_axis(values, weights, q):
     """Per-column weighted percentile of an (N,3) array; q in [0,100]. Confidence weights let
-    low-confidence points (mask-bleed at depth boundaries) count less toward the extent."""
+    low-confidence points (mask-bleed at depth boundaries) count less toward the extent.
+    """
     out = np.empty(values.shape[1], np.float64)
     wsum = weights.sum()
     if wsum <= 0:
@@ -1622,15 +1631,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1666,7 +1671,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         )
         projected = observed @ orientation.T
         _cf = None
-        if _obs_conf is not None and _oi < len(_obs_conf) and _obs_conf[_oi] is not None:
+        if (
+            _obs_conf is not None
+            and _oi < len(_obs_conf)
+            and _obs_conf[_oi] is not None
+        ):
             _cf = np.asarray(_obs_conf[_oi], np.float64)
             _cf = _cf[finite] if len(_cf) == len(finite) else None
         if _cf is not None and len(_cf) == len(projected) and len(projected) >= 8:
@@ -1678,7 +1687,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
             upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1694,7 +1705,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1756,7 +1769,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1855,13 +1871,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2024,9 +2044,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2059,9 +2077,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Consensus Filter At Two Sigma.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2009,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2042,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Decouple Tight Short Axes Stable Longest 030.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1723,7 +1731,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.3) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1822,13 +1833,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1991,9 +2006,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2026,9 +2039,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Decouple Tight Short Axes Stable Longest 040.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1723,7 +1731,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.4) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1822,13 +1833,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1991,9 +2006,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2026,9 +2039,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Decouple Tight Short Axes Stable Longest 050.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1723,7 +1731,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1822,13 +1833,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1991,9 +2006,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2026,9 +2039,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Decouple Tight Short Axes Stable Longest 060.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1723,7 +1731,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.6) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1822,13 +1833,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1991,9 +2006,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2026,9 +2039,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Depth Edge Bleed Cut Alone.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -64,7 +63,9 @@ CONF_PCT = float(os.environ.get("VSI_CONF_PCT", "0"))
 DEPTH_COHERENCE = os.environ.get("VSI_DEPTH_COHERENCE", "1") == "1"
 # cut mask-bleed at per-frame depth edges. Default OFF: it's a NO-OP on the dominant failure (same-depth bleed
 # -- adjacent objects at similar range have no depth edge), and only helps depth-SEPARATED bleed. Enable per-need.
-DEPTH_EDGE_REFINE = os.environ.get("VSI_DEPTH_EDGE_REFINE", "1") == "1"  # HYPOTHESIS: ON -- cut mask-bleed at depth boundaries at the source
+DEPTH_EDGE_REFINE = (
+    os.environ.get("VSI_DEPTH_EDGE_REFINE", "1") == "1"
+)  # HYPOTHESIS: ON -- cut mask-bleed at depth boundaries at the source
 # MASK_REFINE (appearance-guided boundary snap): uses the RGB color edge to clip same-depth mask bleed that
 #   depth can't see. Principled + cheap (CPU, no model). Default OFF until validated; enable via VSI_MASK_REFINE=1.
 MASK_REFINE = os.environ.get("VSI_MASK_REFINE", "0") == "1"
@@ -118,7 +119,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +213,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +439,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +455,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +492,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +519,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +576,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +632,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1234,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1615,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1654,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1672,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1736,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1838,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2011,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2044,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Depth Edge Bleed Cut With Short Axis Median.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -64,7 +63,9 @@ CONF_PCT = float(os.environ.get("VSI_CONF_PCT", "0"))
 DEPTH_COHERENCE = os.environ.get("VSI_DEPTH_COHERENCE", "1") == "1"
 # cut mask-bleed at per-frame depth edges. Default OFF: it's a NO-OP on the dominant failure (same-depth bleed
 # -- adjacent objects at similar range have no depth edge), and only helps depth-SEPARATED bleed. Enable per-need.
-DEPTH_EDGE_REFINE = os.environ.get("VSI_DEPTH_EDGE_REFINE", "1") == "1"  # HYPOTHESIS: ON -- cut mask-bleed at depth boundaries at the source
+DEPTH_EDGE_REFINE = (
+    os.environ.get("VSI_DEPTH_EDGE_REFINE", "1") == "1"
+)  # HYPOTHESIS: ON -- cut mask-bleed at depth boundaries at the source
 # MASK_REFINE (appearance-guided boundary snap): uses the RGB color edge to clip same-depth mask bleed that
 #   depth can't see. Principled + cheap (CPU, no model). Default OFF until validated; enable via VSI_MASK_REFINE=1.
 MASK_REFINE = os.environ.get("VSI_MASK_REFINE", "0") == "1"
@@ -118,7 +119,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +213,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +439,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +455,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +492,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +519,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +576,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +632,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1234,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1615,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1654,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1672,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1736,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1838,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1994,9 +2011,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2029,9 +2044,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Estimate Room Area From Convex Hull Of Coverage.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1778,20 +1784,26 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     # HYPOTHESIS: model the room floor as the CONVEX HULL of all observed floor +
     # object-footprint points, rather than the concave morphological region. Partial camera
     # coverage leaves concave gaps (unvisited corners, occluded strips) that the hull fills in;
     # the hull of the observed extent bounds the room and recovers area the concave region
     # drops, attacking the measured room-area underestimate (ratio ~0.82). No fitted constant.
-    _allpts = np.concatenate([floor_points, footprint_points], axis=0).astype(np.float32)
+    _allpts = np.concatenate([floor_points, footprint_points], axis=0).astype(
+        np.float32
+    )
     if len(_allpts) >= 3:
         _hull = cv2.convexHull(_allpts)[:, 0, :]
         if len(_hull) >= 3:
@@ -1957,9 +1969,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1992,9 +2002,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Estimate Room Area From Oriented Bounding Rectangle Of Floor.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1778,13 +1784,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     # HYPOTHESIS: model the room as the MINIMUM-AREA ORIENTED RECTANGLE enclosing all observed
     # floor + object-footprint points, rather than the concave morphological floor region.
@@ -1793,7 +1803,9 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     # into -- from partial observation, directly attacking the measured systematic room-area
     # underestimate (ratio ~0.82). No fitted constant: it is the tightest rectangle around this
     # scene's own observed points.
-    _allpts = np.concatenate([floor_points, footprint_points], axis=0).astype(np.float32)
+    _allpts = np.concatenate([floor_points, footprint_points], axis=0).astype(
+        np.float32
+    )
     if len(_allpts) >= 3:
         _rect = cv2.minAreaRect(_allpts)
         _box = cv2.boxPoints(_rect)
@@ -1959,9 +1971,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1994,9 +2004,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Extend Box Height To Floor Contact.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1817,13 +1828,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1980,9 +1995,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2015,9 +2028,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Extend Compact Floor Coverage To Every Object Footprint.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1765,13 +1771,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1929,9 +1939,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1964,9 +1972,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Fill Object Footprint Convex Hulls.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1825,13 +1836,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1848,20 +1863,18 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
             footprint = np.asarray(footprint, np.float64)
             if not len(footprint):
                 continue
-            projected_footprint = np.stack(
-                [footprint @ u, footprint @ v], axis=1
-            )
+            projected_footprint = np.stack([footprint @ u, footprint @ v], axis=1)
             projected_footprint = projected_footprint[
                 np.isfinite(projected_footprint).all(axis=1)
             ]
             if not len(projected_footprint):
                 continue
-            cell_rows = (
-                (projected_footprint[:, 0] - x_origin) / resolution
-            ).astype(np.int32) + 1
-            cell_columns = (
-                (projected_footprint[:, 1] - y_origin) / resolution
-            ).astype(np.int32) + 1
+            cell_rows = ((projected_footprint[:, 0] - x_origin) / resolution).astype(
+                np.int32
+            ) + 1
+            cell_columns = ((projected_footprint[:, 1] - y_origin) / resolution).astype(
+                np.int32
+            ) + 1
             if len(projected_footprint) < 3:
                 grid[cell_rows, cell_columns] = 1
                 continue
@@ -2014,9 +2027,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2049,9 +2060,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Floor Contact Plus Tighter Consistency.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1817,13 +1828,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1980,9 +1995,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2015,9 +2028,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Fuller Robust Box By One Ninetynine Per Frame.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 99, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1804,13 +1815,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1967,9 +1982,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2002,9 +2015,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Increase Compact Room Floor Area by 20 Percent.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1732,7 +1738,9 @@ def _compact_scene_points(scene):
     return np.concatenate(points, axis=0) if points else scene["scene_pts"]
 
 
-_ROOM_AREA_FACTOR = 1.20  # HYPOTHESIS: correct the measured reconstruction-coverage undershoot
+_ROOM_AREA_FACTOR = (
+    1.20  # HYPOTHESIS: correct the measured reconstruction-coverage undershoot
+)
 
 
 def _scale_polygon_from_centroid(coordinates, linear_factor):
@@ -1747,7 +1755,8 @@ def _scale_polygon_from_centroid(coordinates, linear_factor):
     structurally a lower bound on true floor area, never an overestimate. Scaling the boundary
     outward from its own centroid is a cheap, shape-preserving way to correct that measured
     bias; since area scales with the SQUARE of a linear scale factor, linear_factor here is
-    sqrt(_ROOM_AREA_FACTOR) so the resulting polygon's area increases by _ROOM_AREA_FACTOR."""
+    sqrt(_ROOM_AREA_FACTOR) so the resulting polygon's area increases by _ROOM_AREA_FACTOR.
+    """
     pts = np.asarray(coordinates, dtype=np.float64)
     if len(pts) < 3:
         return coordinates
@@ -1819,8 +1828,7 @@ def _compact_floor_boundary_polygons(points, u, v):
                     linear_factor,
                 ),
                 "interior hole boundary coordinates": [
-                    _scale_polygon_from_centroid(hole, linear_factor)
-                    for hole in holes
+                    _scale_polygon_from_centroid(hole, linear_factor) for hole in holes
                 ],
             }
         )
@@ -1927,9 +1935,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1962,9 +1968,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Keep More Floor Extent By Wider Clip.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1804,13 +1815,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1967,9 +1982,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2002,9 +2015,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Keep Smaller Observed Floor Patches.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1711,7 +1719,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1810,13 +1821,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1976,9 +1991,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2011,9 +2024,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Longest Axis Full Max Post Decouple.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1728,7 +1736,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     # longest-axis extent now recovered at the FULL max across frames (distance is decoupled
     # onto the tightened short axes, so inflating the longest axis no longer costs distance).
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 1.0) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 1.0)
+            for axis in range(3)
+        ]
     )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1827,13 +1838,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1996,9 +2011,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2031,9 +2044,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Longest Axis View Union Full Post Decouple.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,7 +1734,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     # longest axis also considers the UNION of all views (all clean points at once), which
     # spans the object even when no single frame does. Only the longest axis (size); distance
@@ -1832,13 +1843,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2001,9 +2016,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2036,9 +2049,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Longest Axis View Union Robust Post Decouple.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1726,13 +1734,18 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.5) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     # longest axis also considers the UNION of all views (all clean points at once), which
     # spans the object even when no single frame does. Only the longest axis (size); distance
     # is on the tightened short axes. robust 1/99 union.
     _proj_all = room_points @ orientation.T
-    _union_ext = np.percentile(_proj_all, 99, axis=0) - np.percentile(_proj_all, 1, axis=0)
+    _union_ext = np.percentile(_proj_all, 99, axis=0) - np.percentile(
+        _proj_all, 1, axis=0
+    )
     box_dimensions = tight_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
     box_dimensions[longest_axis] = max(
@@ -1832,13 +1845,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -2001,9 +2018,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2036,9 +2051,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Merge Never-Co-Observed Overlapping Same-Class Tracks.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1811,7 +1817,8 @@ def _compact_duplicate_groups(instances):
     tracked data (no benchmark-fit constant, no scene-relative distance cutoff). Motivated by
     the abs_distance ground-truth comparison (thinking-in-space meta_info object_bbox): the
     worst distance errors concentrate specifically in class pairs with >1 tracked instance,
-    where a spuriously-close near-duplicate track can be picked as the "closest pair"."""
+    where a spuriously-close near-duplicate track can be picked as the "closest pair".
+    """
     count = len(instances)
     parent = list(range(count))
 
@@ -1921,9 +1928,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1956,9 +1961,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Merge Same-Class Instances With Contained Centers.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1655,7 +1659,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1861,7 +1867,8 @@ def _compact_duplicate_groups(instances):
                 np.all(centers[first] >= lower_b) and np.all(centers[first] <= upper_b)
             )
             center_b_in_a = bool(
-                np.all(centers[second] >= lower_a) and np.all(centers[second] <= upper_a)
+                np.all(centers[second] >= lower_a)
+                and np.all(centers[second] <= upper_a)
             )
             if overlap >= 0.8 or center_a_in_b or center_b_in_a:
                 union(first, second)
@@ -1934,9 +1941,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1969,9 +1974,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Orient Compact Boxes By Minimum Area Rectangle.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     # HYPOTHESIS: orient the box by the MINIMUM-AREA enclosing rectangle of the horizontal
     # footprint (cv2.minAreaRect / rotating calipers), not the SVD principal axis. The
     # tightest enclosing rectangle is the most faithful box orientation for a rigid object;
@@ -1661,7 +1665,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1784,13 +1790,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1947,9 +1957,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1982,9 +1990,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Recover Length Axis From View Union Full.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1711,7 +1719,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     # HYPOTHESIS: recover the longest axis from the UNION of all views, not the fullest single
     # frame. full_axis_dimensions above takes the biggest single frame's extent -- but when no
@@ -1821,13 +1832,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1984,9 +1999,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2019,9 +2032,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Recover Length Axis From View Union Robust.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1605,15 +1613,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1648,7 +1652,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1664,7 +1670,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1711,7 +1719,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     # HYPOTHESIS: recover the longest axis from the UNION of all views, not the fullest single
     # frame. full_axis_dimensions above takes the biggest single frame's extent -- but when no
@@ -1721,7 +1732,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     # straight off that combined cloud (robust 1/99 percentile span, so a stray point can't
     # inflate it). Vertical/side axes untouched, so abs_distance is unaffected.
     _proj_all = room_points @ orientation.T
-    _union_ext = np.percentile(_proj_all, 99, axis=0) - np.percentile(_proj_all, 1, axis=0)
+    _union_ext = np.percentile(_proj_all, 99, axis=0) - np.percentile(
+        _proj_all, 1, axis=0
+    )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
     box_dimensions[longest_axis] = max(
@@ -1821,13 +1834,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1984,9 +2001,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2019,9 +2034,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Recover Length Axis Keep Robust Width Depth.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1707,7 +1715,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1803,13 +1814,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1966,9 +1981,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2001,9 +2014,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Recover Length Axis To Full Max.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 1.0) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 1.0)
+            for axis in range(3)
+        ]
     )
     box_dimensions = robust_dimensions.copy()
     longest_axis = int(np.argmax(robust_dimensions))
@@ -1804,13 +1815,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1967,9 +1982,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2002,9 +2015,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Recover Longest Two Axes To Full Extent.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1645,7 +1649,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         upper = np.percentile(projected, 98, axis=0)
         centers.append((lower + upper) / 2)
         dimensions.append(np.maximum(upper - lower, 0.0))
-        full_dimensions.append(np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0))
+        full_dimensions.append(
+            np.maximum(projected.max(axis=0) - projected.min(axis=0), 0.0)
+        )
         weights.append(len(observation))
     if not centers:
         projected = room_points @ orientation.T
@@ -1661,7 +1667,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     full_dimensions = np.asarray(full_dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1708,7 +1716,10 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
         [_weighted_quantile(dimensions[:, axis], weights, 0.9) for axis in range(3)]
     )
     full_axis_dimensions = np.array(
-        [_weighted_quantile(full_dimensions[:, axis], weights, 0.9) for axis in range(3)]
+        [
+            _weighted_quantile(full_dimensions[:, axis], weights, 0.9)
+            for axis in range(3)
+        ]
     )
     # HYPOTHESIS variant: recover full extent on the longest TWO axes, not just the single
     # longest -- when the two largest axes are close, "which is longest" is noisy, and the size
@@ -1807,13 +1818,17 @@ def _compact_floor_boundary_polygons(points, u, v, object_points=None):
     footprint_points = np.zeros((0, 2), np.float64)
     if object_points:
         stacked = [
-            np.stack([np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1)
+            np.stack(
+                [np.asarray(p, np.float64) @ u, np.asarray(p, np.float64) @ v], axis=1
+            )
             for p in object_points
             if len(p)
         ]
         if stacked:
             footprint_points = np.concatenate(stacked, axis=0)
-            footprint_points = footprint_points[np.isfinite(footprint_points).all(axis=1)]
+            footprint_points = footprint_points[
+                np.isfinite(footprint_points).all(axis=1)
+            ]
 
     resolution = 0.1
     combined_for_bounds = np.concatenate([floor_points, footprint_points], axis=0)
@@ -1970,9 +1985,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -2005,9 +2018,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)

experiments/hypotheses/Reject Below-Floor Compact Box Observations.py

@@ -24,7 +24,6 @@ import json
 import numpy as np
 import cv2
 
-
 # ==========================================================================================
 # CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
 # affect only the math below (build_instances/backproject_frame/etc.), never model inference.
@@ -118,7 +117,8 @@ 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)."""
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis).
+    """
     points = []
     for f in range(0, len(depth), fstride):
         height, width = depth[f].shape
@@ -211,7 +211,8 @@ def _floor_basis(up_vec):
     floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
     differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
     rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
-    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too.
+    """
     g = np.asarray(up_vec, np.float64)
     g = g / (np.linalg.norm(g) + 1e-12)
     up_ax = int(np.argmax(np.abs(g)))
@@ -436,7 +437,8 @@ def answer_route(ql, cents, up_vec, up_ax):
 def _sor(pts, k=16, std=2.0, cap=4000):
     """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
     mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
-    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob).
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < k + 2:
@@ -451,7 +453,8 @@ def _sor(pts, k=16, std=2.0, cap=4000):
 def _main_cluster(pts):
     """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
     object forms a disconnected component (a gap separates two objects); the true object is the largest one.
-    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance.
+    """
     from scipy.spatial import cKDTree
 
     if len(pts) < 30:
@@ -487,7 +490,8 @@ def _clean(inst, cap=4000):
       (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
           object's OWN median confidence (data-derived cut);
       (2) statistical density outlier removal on the survivors;
-      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster.
+    """
     if inst.get("_cleanpts") is not None:
         return inst["_cleanpts"]
     pts = inst["pts"]
@@ -513,7 +517,8 @@ 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."""
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring.
+    """
     points_a = _clean(_rep(instances_a), cap=k)
     points_b = _clean(_rep(instances_b), cap=k)
     if len(points_a) == 0 or len(points_b) == 0:
@@ -569,7 +574,8 @@ def refine_mask(mask, rgb):
     """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
     bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
     cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
-    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode.
+    """
     if mask.shape[:2] != rgb.shape[:2]:
         mask = cv2.resize(
             mask.astype(np.uint8),
@@ -624,7 +630,8 @@ def backproject_frame(
     valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
     return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
     edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
-             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection).
+    """
     height, width = depth_f.shape
     empty = (
         (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
@@ -1225,7 +1232,8 @@ def dump_spatial_code(code, path):
     "appearance order" is written as one compact line instead of one line per entry -- it's a
     single ordered sequence meant to be scanned, not structured data meant to be read field by
     field like the rest of the code. Every writer of spatial_code.json should go through this
-    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart.
+    """
     body = dict(code)
     ao = body.pop("appearance order", None)
     text = json.dumps(body, indent=1).rstrip()
@@ -1602,15 +1610,11 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     points = _canonical_clean(instance)
     if not len(points):
         points = instance["pts"]
-    room_points = np.stack(
-        [points @ u, points @ v, points @ g - floor_level], axis=1
-    )
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
     horizontal = room_points[:, :2]
     centered = horizontal - np.median(horizontal, axis=0)
     if len(centered) > 5000:
-        centered = centered[
-            np.random.RandomState(0).choice(len(centered), 5000, False)
-        ]
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
     try:
         _, _, rotation = np.linalg.svd(
             centered - centered.mean(axis=0), full_matrices=False
@@ -1676,7 +1680,9 @@ def _compact_oriented_box(instance, u, v, g, floor_level):
     dimensions = np.asarray(dimensions)
     weights = np.sqrt(np.asarray(weights, np.float64))
     if len(centers) >= 4:
-        features = np.concatenate([centers, np.log(np.maximum(dimensions, 1e-4))], axis=1)
+        features = np.concatenate(
+            [centers, np.log(np.maximum(dimensions, 1e-4))], axis=1
+        )
         median = np.median(features, axis=0)
         deviation = np.abs(features - median)
         scale = 1.4826 * np.median(deviation, axis=0)
@@ -1919,9 +1925,7 @@ def _consolidate_compact_instances(instances, stats, up_axis):
                     instance["centroid"] - fragment["centroid"]
                 ),
             )
-            nearest["first_time"] = min(
-                nearest["first_time"], fragment["first_time"]
-            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
         consolidated[class_name] = retained
     return consolidated
 
@@ -1954,9 +1958,7 @@ def _compact_instances(scene, up_axis):
                     points, up_axis
                 )
                 record = dict(item)
-                record.update(
-                    {"centroid": centroid, "size": size, "dims": dimensions}
-                )
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
                 measured.append(record)
             instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
     instances = _consolidate_compact_instances(instances, stats, up_axis)