Fall back to vertex clustering when quadric decimation stalls

Live check after e0f9b43: the cat now reaches 400 faces, but the SimReady
desk lamp stayed at 22,228 (floor: true, a 522k-character inline page).
Quadric decimation stalls on its sliver triangles at ~21k whatever the
aggression or welding. When that happens, decimate snaps vertices to the
finest grid that reaches the target. Tested on the lamp's real geometry:
it reaches 20000/5000/1000/400/250/60, keeping the arms, shade and base,
which quadric-after-clustering dropped.

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

SPEC.md

@@ -106,7 +106,10 @@ that exists but maps to the wrong thing shows up before submitting.
 
 Ladder rungs: original → 20k / 5k / 1k / 250 / 60 faces → convex hull → oriented
 box. Where the object stops reading as its word is judged in the discussion.
-Decimation welds split vertices (UV and normal seams) between passes. Rungs are
+Decimation welds split vertices (UV and normal seams) between passes. When quadric
+decimation still stalls (CAD meshes with sliver triangles, e.g. a SimReady lamp stuck
+at ~21k faces), vertex clustering takes over: cruder, but it always reduces and keeps
+thin parts. Rungs are
 labelled with the faces they actually have, and the ladder stops descending when
 a rung doesn't reduce, so a stalled mesh never shows as several identical rungs.
 

vli/simplify.py

@@ -34,11 +34,38 @@ def _welded(mesh):
                            process=False)
 
 
+def _clustered(mesh, cell):
+    """Vertex clustering: snap vertices to a grid of `cell` metres and merge each cell."""
+    v, f = np.asarray(mesh.vertices, dtype=np.float64), np.asarray(mesh.faces, dtype=np.int64)
+    inv = np.unique(np.floor((v - v.min(axis=0)) / cell).astype(np.int64), axis=0, return_inverse=True)[1].ravel()
+    nv = np.zeros((inv.max() + 1, 3))
+    np.add.at(nv, inv, v)
+    nv /= np.bincount(inv)[:, None]
+    nf = inv[f]
+    nf = nf[(nf[:, 0] != nf[:, 1]) & (nf[:, 1] != nf[:, 2]) & (nf[:, 0] != nf[:, 2])]
+    return trimesh.Trimesh(nv, nf, process=False)
+
+
+def _cluster_to(mesh, faces):
+    """The finest grid that gets to `faces` or fewer (log-scale bisection on the cell size)."""
+    ext = float(mesh.extents.max()) or 1.0
+    lo, hi, best = ext / 2000, ext / 2, None
+    for _ in range(20):
+        cell = (lo * hi) ** 0.5
+        m = _clustered(mesh, cell)
+        if len(m.faces) > faces:
+            lo = cell
+        else:
+            hi, best = cell, m
+    return best
+
+
 def decimate(mesh, faces):
     """Reduce toward `faces`, re-welding between passes while that still helps.
 
-    The result can stay above `faces` when the mesh has no more structure to collapse
-    (many disconnected parts): callers compare len(result.faces) with what they asked.
+    Quadric decimation stalls on some CAD meshes (long sliver triangles: a SimReady
+    lamp stopped at ~21k faces whatever the settings). Then vertex clustering takes
+    over: cruder, but it always reduces and keeps thin parts that quadric drops.
     """
     color = base_color(mesh)
     out = _welded(mesh)
@@ -47,6 +74,8 @@ def decimate(mesh, faces):
         if len(nxt.faces) > 0.95 * len(out.faces):
             break
         out = nxt
+    if len(out.faces) > faces:
+        out = _cluster_to(out, faces) or out
     out.visual = trimesh.visual.ColorVisuals(out, face_colors=np.tile(color, (len(out.faces), 1)))
     return out