Geometric regularization pass: vertical + Manhattan-direction snap

Two new post-process passes added after snap_horizontal:

- snap_vertical: mirror of snap_horizontal across the up-axis. Near-vertical
edges (small horizontal spread vs vertical spread) get their X and Z forced
equal so the edge is exactly vertical.

- snap_manhattan: detects the dominant XZ-plane building direction of all
near-horizontal edges via a 4x-angle circular mean (90 deg symmetry). Edges
within 3 deg of the dominant direction or its perpendicular are snapped to
align exactly, via 3 iterations of Gauss-Seidel vertex averaging so shared
endpoints converge consistently without drift. Non-Manhattan wireframes
(hexagonal roofs, complex geometry) leave untouched because no edges fall
within tolerance.

Both passes are no-ops on edges that don't qualify; order is safe. Mathematically
distinct from the reverted 6cf3fbd's snap changes (which touched target_classes
and snap_horizontal incident-edge logic).

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

s23dr_2026_example/postprocess_v2.py

@@ -37,3 +37,111 @@ 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

@@ -50,7 +50,9 @@ 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
+from s23dr_2026_example.postprocess_v2 import (
+    snap_to_point_cloud, snap_horizontal, snap_vertical, snap_manhattan,
+)
 
 SEQ_LEN = 4096
 COLMAP_QUOTA = 3072
@@ -232,8 +234,11 @@ 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)
 
-    # Horizontal snap
+    # 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.
     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()