Revert: roll back COLMAP refine + junction + snap changes

The previous commit's changes regressed the leaderboard score:
- hss_mean: 0.4583 -> 0.4443 (-0.014)
- corner_f1: 0.5104 -> 0.5003 (-0.010)
- edge_iou: 0.4268 -> 0.4101 (-0.017)

Most likely culprits without local validation:
- COLMAP multi-view plane refinement: snapped some vertices onto wall
or ground planes instead of roof planes (corner_f1 hit).
- Junction constraints: the leaf_min_len=0.4m and collinear_cos=0.97
thresholds removed valid short edges and corner vertices (edge_iou hit).
- Loosened hybrid_merge admitted incorrect track edges between
existing predicted vertices.

Restore script.py and s23dr_2026_example/postprocess_v2.py to the state
from commit 9deb9e1 (the previous best, hss_mean=0.4583). Tomorrow we
can attempt smaller, targeted experiments one at a time.

s23dr_2026_example/postprocess_v2.py

@@ -6,7 +6,7 @@ def snap_to_point_cloud(vertices, xyz, class_id, snap_radius=0.5,
                          target_classes=None):
     """Snap vertices to nearby point cloud clusters of specific semantic classes."""
     if target_classes is None:
-        target_classes = [1, 2, 3]  # apex, eave_end_point, flashing_end_point
+        target_classes = [1, 2]  # apex, eave_end_point
 
     snapped = vertices.copy()
     mask = np.isin(class_id, target_classes)
@@ -26,39 +26,14 @@ def snap_to_point_cloud(vertices, xyz, class_id, snap_radius=0.5,
 
 
 def snap_horizontal(vertices, edges, max_slope=0.05):
-    """Snap near-horizontal edges to be exactly horizontal.
-
-    Only snaps a vertex if ALL of its incident edges are near-horizontal —
-    otherwise we would corrupt sloped edges that share the vertex.
-    """
+    """Snap near-horizontal edges to be exactly horizontal."""
     verts = vertices.copy()
-    n = len(verts)
-    if n == 0 or len(edges) == 0:
-        return verts
-
-    edge_is_h = []
-    incident = [[] for _ in range(n)]
-    for ei, (a, b) in enumerate(edges):
+    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)
-        is_h = dxz > 0.1 and dy / dxz < max_slope
-        edge_is_h.append(is_h)
-        incident[a].append(ei)
-        incident[b].append(ei)
-
-    purely_h = [
-        len(incident[v]) > 0 and all(edge_is_h[ei] for ei in incident[v])
-        for v in range(n)
-    ]
-
-    for ei, (a, b) in enumerate(edges):
-        if not edge_is_h[ei]:
-            continue
-        a, b = int(a), int(b)
-        if not (purely_h[a] and purely_h[b]):
-            continue
-        avg_y = 0.5 * (verts[a, 1] + verts[b, 1])
-        verts[a, 1] = avg_y
-        verts[b, 1] = avg_y
+        dxz = np.sqrt((verts[a, 0] - verts[b, 0])**2 + (verts[a, 2] - verts[b, 2])**2)
+        if dxz > 0.1 and dy / dxz < max_slope:
+            avg_y = 0.5 * (verts[a, 1] + verts[b, 1])
+            verts[a, 1] = avg_y
+            verts[b, 1] = avg_y
     return verts

script.py

@@ -293,38 +293,18 @@ def hybrid_merge(pred_v, pred_e, track_v, track_e, merge_radius=0.8):
     for u, v in final_e:
         existing_edges.add((min(u, v), max(u, v)))
         
-    # Tight-confidence radius for accepting a track edge between two
-    # already-existing predicted vertices (topology correction).
-    tight_radius = 0.3
-
     for u_t, v_t in track_e:
         u_f = track_to_final.get(u_t)
         v_f = track_to_final.get(v_t)
-        if u_f is None or v_f is None or u_f == v_f:
-            continue
-        e = (min(u_f, v_f), max(u_f, v_f))
-        if e in existing_edges:
-            continue
-
-        u_is_new = u_f >= len(pred_v)
-        v_is_new = v_f >= len(pred_v)
-
-        if u_is_new or v_is_new:
-            # New vertex: trust the track edge.
-            final_e.append(e)
-            existing_edges.add(e)
-            continue
-
-        # Both endpoints are existing predicted vertices — only accept the
-        # track edge as a topology correction when both are very confidently
-        # matched (tight distance). This recovers missing edges without
-        # letting the tracker rewire the learned topology.
-        d_u = dists[u_t] if u_t < len(dists) else np.inf
-        d_v = dists[v_t] if v_t < len(dists) else np.inf
-        if d_u <= tight_radius and d_v <= tight_radius:
-            final_e.append(e)
-            existing_edges.add(e)
-
+        if u_f is not None and v_f is not None and u_f != v_f:
+            e = (min(u_f, v_f), max(u_f, v_f))
+            if e not in existing_edges:
+                # ONLY append the tracked edge if it connects to a NEWLY DISCOVERED vertex.
+                # This prevents the geometric tracker from aggressively re-wiring the learned model's existing topology!
+                if u_f >= len(pred_v) or v_f >= len(pred_v):
+                    final_e.append(e)
+                    existing_edges.add(e)
+                    
     return np.array(final_v), final_e
 
 # ---------------------------------------------------------------------------
@@ -417,44 +397,11 @@ if __name__ == "__main__":
                         from triangulation import predict_wireframe_tracks
                         # Use min_views=3 for highly precise, conservative geometric tracks
                         track_v, track_e = predict_wireframe_tracks(sample, min_views=3)
-
+                        
                         pred_v, pred_e = hybrid_merge(pred_v, pred_e, track_v, track_e, merge_radius=0.8)
                     except Exception as track_e_err:
                         print(f"  Track ensemble failed for {order_id}: {track_e_err}")
-
-                    # COLMAP multi-view plane refinement: snaps each vertex to the
-                    # roof plane visible at its 2D projection. Targets corner_f1.
-                    try:
-                        if isinstance(pred_v, np.ndarray) and len(pred_v) >= 1:
-                            from colmap_refine import refine_vertices_multiview_plane
-                            refined, snapped_mask = refine_vertices_multiview_plane(
-                                pred_v, sample,
-                                knn_2d_px=30.0, knn_k=12, min_neighbours=6,
-                                max_displacement=0.5, min_quality=0.5, min_views=2,
-                            )
-                            if snapped_mask.any():
-                                pred_v = refined
-                    except Exception as refine_err:
-                        print(f"  COLMAP refine failed for {order_id}: {refine_err}")
-
-                    # Junction constraints: drop collinear/duplicate/short-leaf edges
-                    try:
-                        if isinstance(pred_v, np.ndarray) and len(pred_v) >= 2 and len(pred_e) >= 1:
-                            from junction import apply_junction_constraints
-                            jv, je = apply_junction_constraints(
-                                pred_v, pred_e,
-                                collinear_cos=0.97,
-                                duplicate_cos=0.985,
-                                leaf_min_len=0.4,
-                                max_passes=3,
-                            )
-                            # Only accept if at least one edge survives — never let
-                            # the post-processing reduce us to an empty graph.
-                            if len(je) >= 1:
-                                pred_v, pred_e = jv, je
-                    except Exception as junc_err:
-                        print(f"  Junction constraints failed for {order_id}: {junc_err}")
-
+                        
                 except Exception as e:
                     import traceback
                     print(f"  Predict failed for {order_id}:\n{traceback.format_exc()}")