Add learned + classical pipeline ensemble (LOCAL only, push tomorrow)

After hybrid_merge, also run predict_wireframe_sklearn (the full
classical pipeline with line cloud, winner candidates, sklearn edge
classifier, track ensemble) and union its output with the
learned-pipeline output via ensemble_merge.

ensemble_merge:
- Vertex union with close-pair merging (0.4m radius via cKDTree).
- Edge union after re-mapping classical edge endpoints onto merged
vertex indices, deduplicating undirected edge pairs.
- Robust to NaN/Inf vertices from the classical side.

Wrapped in try/except so a sklearn-pipeline failure on any sample
falls back to the existing learned + hybrid_merge output. Independent
error modes between the two pipelines should complement each other
(semantic 2D detection + line cloud + sklearn classifier vs learned 3D
segment regression).

DO NOT PUSH today — daily submission slot already used (commit 56f1ec6
scored 0.4584). Push tomorrow when budget refreshes.

script.py

@@ -307,6 +307,71 @@ def hybrid_merge(pred_v, pred_e, track_v, track_e, merge_radius=0.8):
                     
     return np.array(final_v), final_e
 
+
+def ensemble_merge(v1, e1, v2, e2, vertex_merge_radius=0.4):
+    """Merge two pipeline outputs (learned + classical) into a single wireframe.
+
+    Strategy: vertex union with merging of close pairs, edge union after
+    re-mapping classical-pipeline edge endpoints onto merged vertex indices.
+
+    Both inputs are expected to be (vertices ndarray/list, edges list-of-tuples).
+    """
+    v1 = np.array(v1, dtype=np.float64) if isinstance(v1, list) else np.asarray(v1, dtype=np.float64)
+    v2 = np.array(v2, dtype=np.float64) if isinstance(v2, list) else np.asarray(v2, dtype=np.float64)
+
+    if v2.size == 0 or len(v2) == 0:
+        return v1, list(e1)
+    if v1.size == 0 or len(v1) == 0:
+        return v2, list(e2)
+
+    # Filter out non-finite vertices in v2
+    valid2 = np.isfinite(v2).all(axis=1)
+    if not valid2.all():
+        idx_map_2 = {int(old): new for new, old in enumerate(np.where(valid2)[0])}
+        v2 = v2[valid2]
+        e2 = [(idx_map_2[int(u)], idx_map_2[int(v)]) for u, v in e2
+              if int(u) in idx_map_2 and int(v) in idx_map_2]
+
+    if len(v2) == 0:
+        return v1, list(e1)
+
+    from scipy.spatial import cKDTree
+    tree = cKDTree(v1)
+    dists, indices = tree.query(v2, k=1)
+
+    v2_to_merged = {}
+    new_vertices = []
+    for i, (d, j) in enumerate(zip(dists, indices)):
+        if d <= vertex_merge_radius:
+            v2_to_merged[i] = int(j)
+        else:
+            v2_to_merged[i] = len(v1) + len(new_vertices)
+            new_vertices.append(v2[i])
+
+    final_v = np.vstack([v1, np.array(new_vertices, dtype=np.float64)]) if new_vertices else v1
+    final_e_set = set()
+    final_e = []
+    for u, v in e1:
+        u, v = int(u), int(v)
+        if u == v:
+            continue
+        e = (min(u, v), max(u, v))
+        if e not in final_e_set:
+            final_e_set.add(e)
+            final_e.append(e)
+    for u, v in e2:
+        u_m = v2_to_merged.get(int(u))
+        v_m = v2_to_merged.get(int(v))
+        if u_m is None or v_m is None or u_m == v_m:
+            continue
+        e = (min(u_m, v_m), max(u_m, v_m))
+        if e not in final_e_set:
+            final_e_set.add(e)
+            final_e.append(e)
+
+    return final_v, final_e
+
+
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -397,11 +462,27 @@ 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}")
-                        
+
+                    # Pipeline ensemble: also run the classical sklearn pipeline
+                    # and union with the learned-pipeline output. Independent
+                    # error modes (semantic 2D detection + line cloud + sklearn
+                    # edge classifier) complement the learned 3D segment regression.
+                    try:
+                        from sklearn_submission import predict_wireframe_sklearn
+                        skl_v, skl_e = predict_wireframe_sklearn(sample)
+                        if isinstance(pred_v, np.ndarray) and len(pred_v) >= 1 and \
+                                skl_v is not None and len(skl_v) >= 1:
+                            pred_v, pred_e = ensemble_merge(
+                                pred_v, pred_e, skl_v, skl_e,
+                                vertex_merge_radius=0.4,
+                            )
+                    except Exception as ens_err:
+                        print(f"  Ensemble merge failed for {order_id}: {ens_err}")
+
                 except Exception as e:
                     import traceback
                     print(f"  Predict failed for {order_id}:\n{traceback.format_exc()}")