Rollback to proven 0.4584 baseline, add plane_wireframe to ensemble

Two changes in one commit:

1. ROLLBACK: revert script.py and postprocess_v2.py to commit 56f1ec6 contents
(the highest-scoring submission at hss_mean=0.4584). Removes snap_vertical +
snap_manhattan (regressed edge_iou -0.009 in 72962c4) and the
filter_by_colmap_support step (added in 6ecd5f8 but never independently
evaluated, so its effect is unknown).

2. NEW: wire plane_wireframe.predict_wireframe_planes into the ensemble as a
third recall source after triangulation tracks. RANSAC-segments roof planes
from the COLMAP cloud and intersects them to recover ridge/eave edges the
learned model misses. The module was fully implemented but never wired in.
Uses the same append-only hybrid_merge(radius=0.8) pattern as triangulation,
so it only adds genuinely new vertices/edges; cannot corrupt existing
topology. Wrapped in try/except so any failure falls back silently to the
pre-plane prediction.

Runtime deps open3d and scikit-spatial added via install_if_missing (extended
to accept a separate pip_name for packages whose import name differs).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

s23dr_2026_example/postprocess_v2.py

@@ -37,111 +37,3 @@ def snap_horizontal(vertices, edges, max_slope=0.05):
             verts[a, 1] = avg_y
             verts[b, 1] = avg_y
     return verts
-
-
-def snap_vertical(vertices, edges, max_slope=0.05):
-    """Snap near-vertical edges to be exactly vertical (shared X and Z).
-
-    Mirror of snap_horizontal across the up-axis. A near-vertical edge has
-    a small horizontal spread (dxz) relative to its vertical spread (dy).
-    """
-    verts = vertices.copy()
-    for a, b in edges:
-        a, b = int(a), int(b)
-        dy = abs(verts[a, 1] - verts[b, 1])
-        dxz = np.sqrt((verts[a, 0] - verts[b, 0]) ** 2 + (verts[a, 2] - verts[b, 2]) ** 2)
-        if dy > 0.1 and dxz / dy < max_slope:
-            avg_x = 0.5 * (verts[a, 0] + verts[b, 0])
-            avg_z = 0.5 * (verts[a, 2] + verts[b, 2])
-            verts[a, 0] = avg_x
-            verts[a, 2] = avg_z
-            verts[b, 0] = avg_x
-            verts[b, 2] = avg_z
-    return verts
-
-
-def snap_manhattan(vertices, edges, tol_deg=3.0, min_count=4, n_iters=3):
-    """Snap near-axis-aligned horizontal edges to a single dominant building direction.
-
-    Detects the dominant XZ-plane direction of near-horizontal edges via a
-    doubled-angle circular mean (so direction and its 90° rotation reinforce
-    each other). Edges within ``tol_deg`` of that direction or its perpendicular
-    are rotated about their midpoint to align exactly. Endpoints shared between
-    multiple snapped edges are averaged (Gauss-Seidel, ``n_iters`` passes) to
-    converge to a Manhattan-consistent position without drift.
-
-    Only operates in the XZ plane; Y is preserved (use snap_horizontal /
-    snap_vertical for Y handling). Returns vertices unchanged if fewer than
-    ``min_count`` near-horizontal edges exist (insufficient evidence).
-    """
-    verts = np.asarray(vertices, dtype=np.float64).copy()
-    n_verts = len(verts)
-    n_edges = len(edges)
-    if n_verts < 2 or n_edges < min_count:
-        return vertices
-
-    # Classify each edge once: near-horizontal? full-angle in XZ?
-    edge_data = []  # list of (a, b, full_ang) for near-horizontal edges only
-    for a, b in edges:
-        a, b = int(a), int(b)
-        dx = verts[b, 0] - verts[a, 0]
-        dy = verts[b, 1] - verts[a, 1]
-        dz = verts[b, 2] - verts[a, 2]
-        dxz = np.sqrt(dx * dx + dz * dz)
-        if dxz < 0.2:
-            continue
-        if abs(dy) / dxz > 0.1:
-            continue
-        full_ang = np.arctan2(dz, dx)
-        edge_data.append((a, b, full_ang))
-
-    if len(edge_data) < min_count:
-        return vertices
-
-    # Dominant Manhattan direction via 4×-angle circular mean: a building grid
-    # has 90° symmetry, so edges at θ, θ+90°, θ+180°, θ+270° must reinforce each
-    # other in the estimate. Multiply by 4 to fold [0, π/2) → [0, 2π), take the
-    # circular mean, divide by 4.
-    quad = np.array([4.0 * e[2] for e in edge_data])
-    peak_ang = 0.25 * np.arctan2(np.sin(quad).mean(), np.cos(quad).mean())
-
-    # Identify edges to snap and pick the best axis (peak, peak+π/2, peak+π, peak+3π/2)
-    tol = np.deg2rad(tol_deg)
-    snap_targets = []  # (a, b, ux, uz)
-    candidates = [peak_ang + k * (np.pi / 2.0) for k in range(4)]
-    for a, b, full_ang in edge_data:
-        diffs = [abs(((full_ang - c + np.pi) % (2 * np.pi)) - np.pi) for c in candidates]
-        k = int(np.argmin(diffs))
-        if diffs[k] >= tol:
-            continue
-        target = candidates[k]
-        snap_targets.append((a, b, float(np.cos(target)), float(np.sin(target))))
-
-    if not snap_targets:
-        return vertices
-
-    # Gauss-Seidel: each iteration, accumulate target endpoint positions per
-    # vertex and average. Y is left untouched.
-    for _ in range(n_iters):
-        sum_xz = np.zeros((n_verts, 2), dtype=np.float64)
-        count = np.zeros(n_verts, dtype=np.int64)
-        for a, b, ux, uz in snap_targets:
-            mx = 0.5 * (verts[a, 0] + verts[b, 0])
-            mz = 0.5 * (verts[a, 2] + verts[b, 2])
-            dx = verts[b, 0] - verts[a, 0]
-            dz = verts[b, 2] - verts[a, 2]
-            length = abs(dx * ux + dz * uz)  # projection of edge onto snap dir
-            half = 0.5 * length
-            sum_xz[a, 0] += mx - ux * half
-            sum_xz[a, 1] += mz - uz * half
-            sum_xz[b, 0] += mx + ux * half
-            sum_xz[b, 1] += mz + uz * half
-            count[a] += 1
-            count[b] += 1
-        moved = count > 0
-        if not moved.any():
-            break
-        verts[moved, 0] = sum_xz[moved, 0] / count[moved]
-        verts[moved, 2] = sum_xz[moved, 1] / count[moved]
-
-    return verts.astype(np.asarray(vertices).dtype)

script.py

@@ -8,14 +8,16 @@ os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
 import subprocess
 import sys
 
-def install_if_missing(package):
+def install_if_missing(package, pip_name=None):
     try:
         __import__(package.split("==")[0])
     except ImportError:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+        subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name or package])
 
 install_if_missing("scipy")
 install_if_missing("pandas")
+install_if_missing("open3d")
+install_if_missing("skspatial", pip_name="scikit-spatial")
 
 from pathlib import Path
 from tqdm import tqdm
@@ -50,9 +52,7 @@ from s23dr_2026_example.tokenizer import EdgeDepthSequenceConfig
 from s23dr_2026_example.model import EdgeDepthSegmentsModel
 from s23dr_2026_example.segment_postprocess import merge_vertices_iterative
 from s23dr_2026_example.varifold import segments_to_vertices_edges
-from s23dr_2026_example.postprocess_v2 import (
-    snap_to_point_cloud, snap_horizontal, snap_vertical, snap_manhattan,
-)
+from s23dr_2026_example.postprocess_v2 import snap_to_point_cloud, snap_horizontal
 
 SEQ_LEN = 4096
 COLMAP_QUOTA = 3072
@@ -234,11 +234,8 @@ def predict_sample(sample_dict, model, device):
     cid_valid = cid[mask]
     pv = snap_to_point_cloud(pv, xyz_world, cid_valid, snap_radius=SNAP_RADIUS)
 
-    # Axis snaps: horizontal, then vertical, then Manhattan-direction in XZ.
-    # Each pass is a no-op on edges that don't qualify, so order is safe.
+    # Horizontal snap
     pv = snap_horizontal(pv, pe)
-    pv = snap_vertical(pv, pe)
-    pv = snap_manhattan(pv, pe)
 
     if len(pv) < 2 or len(pe) < 1:
         return empty_solution()
@@ -312,62 +309,6 @@ def hybrid_merge(pred_v, pred_e, track_v, track_e, merge_radius=0.8):
                     
     return np.array(final_v), final_e
 
-
-def filter_by_colmap_support(pv, pe, sample, support_radius=0.6):
-    """Drop predicted vertices that have NO COLMAP point within support_radius.
-
-    Hallucinated vertices from the model (predicted in 3D space with no real
-    geometric evidence) typically appear in regions with no COLMAP point cloud.
-    Filtering by COLMAP-presence is a precision-only operation: real vertices
-    survive (the COLMAP cloud covers all reconstructed regions of the building),
-    spurious model outputs in empty space get dropped.
-
-    Returns the filtered (vertices, edges). On any failure or empty result,
-    falls back to the unfiltered input to avoid an empty submission.
-    """
-    try:
-        if not isinstance(pv, np.ndarray) or len(pv) < 2 or len(pe) < 1:
-            return pv, pe
-        from hoho2025.example_solutions import convert_entry_to_human_readable
-        good = convert_entry_to_human_readable(sample)
-        colmap_rec = good.get('colmap') or good.get('colmap_binary')
-        if colmap_rec is None:
-            return pv, pe
-        colmap_xyz = np.array(
-            [p.xyz for p in colmap_rec.points3D.values()], dtype=np.float64
-        )
-        if len(colmap_xyz) < 5:
-            return pv, pe
-
-        from scipy.spatial import cKDTree
-        tree = cKDTree(colmap_xyz)
-        dists, _ = tree.query(np.asarray(pv, dtype=np.float64), k=1)
-        keep_mask = dists <= support_radius
-
-        if keep_mask.all():
-            return pv, pe  # nothing to filter
-
-        n_keep = int(keep_mask.sum())
-        # Require at least 2 vertices and 1 edge to remain after filtering.
-        if n_keep < 2:
-            return pv, pe
-
-        old_to_new = {int(old): new for new, old in enumerate(np.where(keep_mask)[0])}
-        new_pv = pv[keep_mask]
-        new_pe = []
-        for u, v in pe:
-            u, v = int(u), int(v)
-            if u in old_to_new and v in old_to_new and u != v:
-                new_pe.append((old_to_new[u], old_to_new[v]))
-
-        if len(new_pe) < 1:
-            return pv, pe  # do not drop all edges
-
-        return new_pv, new_pe
-    except Exception:
-        return pv, pe
-
-
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -463,14 +404,20 @@ if __name__ == "__main__":
                     except Exception as track_e_err:
                         print(f"  Track ensemble failed for {order_id}: {track_e_err}")
 
-                    # Final precision pass: drop vertices with no nearby COLMAP
-                    # support. These are the model's hallucinations in regions
-                    # with no geometric evidence. Internal fallbacks ensure we
-                    # never end up with fewer than 2 vertices / 1 edge.
-                    pred_v, pred_e = filter_by_colmap_support(
-                        pred_v, pred_e, sample, support_radius=0.6,
-                    )
-
+                    # Apply plane-intersection wireframe: RANSAC roof planes from the
+                    # COLMAP cloud, intersect them to recover ridge/eave edges the
+                    # learned model may miss. Recall-focused, geometry-only signal.
+                    # hybrid_merge keeps it append-only at merge_radius=0.8.
+                    try:
+                        from plane_wireframe import predict_wireframe_planes
+                        plane_v, plane_e = predict_wireframe_planes(sample)
+                        if len(plane_v) > 0 and len(plane_e) > 0:
+                            pred_v, pred_e = hybrid_merge(
+                                pred_v, pred_e, plane_v, plane_e, merge_radius=0.8,
+                            )
+                    except Exception as plane_err:
+                        print(f"  Plane ensemble failed for {order_id}: {plane_err}")
+                        
                 except Exception as e:
                     import traceback
                     print(f"  Predict failed for {order_id}:\n{traceback.format_exc()}")