Fix all post-processing errors on ZeroGPU/headless environment

Repair (stage2_repair.py):
- Remove verbose=False from PyTMesh() — kwarg dropped in pymeshfix ≥0.17

Cleanup (stage2_cleanup.py):
- Remove remove_duplicate_faces() call — removed from trimesh 4.x
- Replace entire PyMeshLab filter chain with trimesh process=True +
trimesh.repair.fix_winding/fix_normals (no OpenGL dependency)

Decimation (stage2_decimate.py):
- Replace PyMeshLab quadric decimation with fast_simplification
(VTK-based, no libOpenGL.so.0 needed); both preview and final pass
now use the same fast_simplification.simplify() call

LODs (stage2_finalize.py):
- Same: replace PyMeshLab+PLY intermediate with fast_simplification
directly on trimesh vertices/faces

requirements.txt:
- Remove pymeshlab (its filter plugins need libOpenGL.so.0 which is
absent on headless ZeroGPU Spaces — causes "Unknown format for load: ply")

nvdiffrast ABI mismatch (_ZN3c107WarningC1E... symbol) is a known issue
with the torch 2.6.0-compiled wheel on torch 2.8.0; baking stages already
degrade gracefully to default values.

requirements.txt

@@ -38,7 +38,9 @@ onnxruntime
 # ===== Milestone 3: Stage 2A-2C Mesh Cleanup =====
 trimesh[easy]
 pymeshfix
-pymeshlab
+# pymeshlab excluded: its mesh-filter plugins need libOpenGL.so.0 which is
+# absent on ZeroGPU Spaces (headless, no display server).  Decimation and
+# LOD generation use fast-simplification (VTK, no OpenGL) instead.
 fast-simplification
 
 # ===== Milestone 4: Stage 2D-2E UV + Symmetry =====

src/stages/stage2_cleanup.py

@@ -1,7 +1,12 @@
-"""Stage 2B — Geometry cleanup with trimesh + PyMeshLab."""
+"""Stage 2B — Geometry cleanup.
+
+Uses trimesh only (no PyMeshLab) because PyMeshLab's mesh-processing
+plugins require libOpenGL.so.0 which is absent on ZeroGPU Spaces.
+trimesh's process=True flag handles duplicate verts/faces, unreferenced
+vertices, degenerate triangles, and zero-length edges.
+"""
 from __future__ import annotations
 
-import tempfile
 from pathlib import Path
 
 from src import workspace
@@ -11,45 +16,27 @@ from src.workspace import CURRENT
 def cleanup_mesh(input_glb: Path) -> tuple[Path, str]:
     """Remove duplicate verts/faces, degenerate geometry, non-manifold elements."""
     import trimesh
-    import pymeshlab
-
-    # Load and do a first pass with trimesh (fast, handles basic issues)
-    mesh = trimesh.load(str(input_glb), force="mesh")
-    mesh.remove_duplicate_faces()
-    mesh.remove_unreferenced_vertices()
-    mesh.remove_infinite_values()
-    mesh.merge_vertices(merge_tex=False)
-
-    # Export to PLY for PyMeshLab (more reliable than GLB roundtrip in pymeshlab)
-    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-        ply_in = tmp.name
-    mesh.export(ply_in)
-
-    ms = pymeshlab.MeshSet()
-    ms.load_new_mesh(ply_in)
-
-    # Remove degenerate and null faces
-    ms.apply_filter("meshing_remove_null_faces")
-    # Remove duplicate verts
-    ms.apply_filter("meshing_remove_duplicate_vertices")
-    # Remove unreferenced verts
-    ms.apply_filter("meshing_remove_unreferenced_vertices")
-    # Fix non-manifold edges (remove offending faces)
-    ms.apply_filter("meshing_repair_non_manifold_edges")
-    # Fix non-manifold verts (split)
-    ms.apply_filter("meshing_repair_non_manifold_vertices")
-
-    face_count = ms.current_mesh().face_number()
-
-    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-        ply_out = tmp.name
-    ms.save_current_mesh(ply_out)
-
-    out_mesh = trimesh.load(ply_out, force="mesh")
+
+    raw = trimesh.load(str(input_glb), force="mesh")
+
+    # Re-instantiate with process=True: trims duplicate faces, unreferenced
+    # vertices, degenerate triangles, and merges identical vertices.
+    mesh = trimesh.Trimesh(
+        vertices=raw.vertices,
+        faces=raw.faces,
+        process=True,
+        validate=True,
+    )
+
+    # Fix face winding inconsistencies
+    trimesh.repair.fix_winding(mesh)
+    # Remove faces whose normal is degenerate (zero-length cross product)
+    trimesh.repair.fix_normals(mesh)
+
     out_path = CURRENT / "cleaned.glb"
-    out_mesh.export(str(out_path))
+    mesh.export(str(out_path))
 
     state = workspace.get_state()
     state.cleaned_glb = out_path
 
-    return out_path, f"Cleanup: {face_count:,} faces"
+    return out_path, f"Cleanup: {len(mesh.faces):,} faces"

src/stages/stage2_decimate.py

@@ -1,18 +1,24 @@
 """Stage 2C — Mesh decimation.
 
-Two modes:
-  preview  — fast-simplification (CPU, ~seconds) for live slider feedback
-  final    — PyMeshLab quadric edge collapse (quality-preserving) for export
+Uses fast_simplification (VTK-based, no OpenGL) for both the live preview
+and the final quality pass.  PyMeshLab is not used here because its mesh
+filter plugins require libOpenGL.so.0 which is absent on ZeroGPU Spaces.
 """
 from __future__ import annotations
 
-import tempfile
 from pathlib import Path
 
 from src import workspace
 from src.workspace import CURRENT
 
 
+def _reduction_ratio(current_faces: int, target_faces: int) -> float:
+    """Fraction of faces to REMOVE (fast_simplification convention)."""
+    if target_faces >= current_faces:
+        return 0.0
+    return max(0.0, min(1.0 - target_faces / current_faces, 0.99))
+
+
 def decimate_preview(input_glb: Path, target_faces: int) -> tuple[int, int]:
     """Quick decimation for live slider feedback. Returns (face_count, vertex_count)."""
     import trimesh
@@ -24,57 +30,38 @@ def decimate_preview(input_glb: Path, target_faces: int) -> tuple[int, int]:
     if target_faces >= current_faces:
         return current_faces, len(mesh.vertices)
 
-    ratio = 1.0 - target_faces / current_faces
-    ratio = max(0.0, min(ratio, 0.99))
-
+    ratio = _reduction_ratio(current_faces, target_faces)
     pts_out, faces_out = fast_simplification.simplify(
         mesh.vertices, mesh.faces, target_reduction=ratio
     )
-
     return len(faces_out), len(pts_out)
 
 
 def decimate_mesh_final(input_glb: Path, target_faces: int) -> tuple[Path, str]:
-    """Quality-preserving decimation via PyMeshLab quadric edge collapse."""
+    """Decimation via fast_simplification (quadric-based, VTK backend)."""
     import trimesh
-    import pymeshlab
+    import fast_simplification
 
     mesh = trimesh.load(str(input_glb), force="mesh")
     current_faces = len(mesh.faces)
 
     if target_faces >= current_faces:
-        # Already at or below target — just copy state
         out_path = CURRENT / "low_poly.glb"
         mesh.export(str(out_path))
         state = workspace.get_state()
         state.low_poly_glb = out_path
         return out_path, f"Decimation skipped (mesh already at {current_faces:,} faces)"
 
-    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-        ply_in = tmp.name
-    mesh.export(ply_in)
-
-    ms = pymeshlab.MeshSet()
-    ms.load_new_mesh(ply_in)
-    ms.apply_filter(
-        "meshing_decimation_quadric_edge_collapse",
-        targetfacenum=target_faces,
-        preservenormal=True,
-        preservetopology=True,
-        autoclean=True,
+    ratio = _reduction_ratio(current_faces, target_faces)
+    pts_out, faces_out = fast_simplification.simplify(
+        mesh.vertices, mesh.faces, target_reduction=ratio
     )
 
-    face_count = ms.current_mesh().face_number()
-
-    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-        ply_out = tmp.name
-    ms.save_current_mesh(ply_out)
-
-    out_mesh = trimesh.load(ply_out, force="mesh")
+    out_mesh = trimesh.Trimesh(vertices=pts_out, faces=faces_out, process=False)
     out_path = CURRENT / "low_poly.glb"
     out_mesh.export(str(out_path))
 
     state = workspace.get_state()
     state.low_poly_glb = out_path
 
-    return out_path, f"Decimation: {current_faces:,} → {face_count:,} faces"
+    return out_path, f"Decimation: {current_faces:,} → {len(faces_out):,} faces"

src/stages/stage2_finalize.py

@@ -53,54 +53,39 @@ def pack_orm(ao_path: Path | None, roughness_path: Path | None, metallic_path: P
 # ---------------------------------------------------------------------------
 
 def generate_lods(input_glb: Path, lod_ratios: tuple = (1.0, 0.5, 0.25)) -> tuple[list[Path], str]:
-    """
-    Generate LOD0/LOD1/LOD2 via PyMeshLab quadric decimation.
-    lod_ratios: face-count multipliers relative to input (1.0 = full).
+    """Generate LOD0/LOD1/LOD2 via fast_simplification (VTK, no OpenGL needed).
+
+    lod_ratios: face-count multipliers relative to input (1.0 = full res).
     """
     import trimesh
-    import pymeshlab
-    import tempfile
+    import fast_simplification
 
     mesh = trimesh.load(str(input_glb), force="mesh")
     base_faces = len(mesh.faces)
 
-    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-        ply_in = tmp.name
-    mesh.export(ply_in)
-
     CURRENT_LODS.mkdir(parents=True, exist_ok=True)
 
     lod_paths = []
+    actual_counts = []
     for idx, ratio in enumerate(lod_ratios):
-        target = max(100, int(base_faces * ratio))
-
-        if ratio == 1.0:
-            out = CURRENT_LODS / f"LOD{idx}.glb"
+        out = CURRENT_LODS / f"LOD{idx}.glb"
+        if ratio >= 1.0:
             mesh.export(str(out))
+            actual_counts.append(base_faces)
         else:
-            ms = pymeshlab.MeshSet()
-            ms.load_new_mesh(ply_in)
-            ms.apply_filter(
-                "meshing_decimation_quadric_edge_collapse",
-                targetfacenum=target,
-                preservenormal=True,
-                preservetopology=True,
-                autoclean=True,
+            reduction = max(0.0, min(1.0 - ratio, 0.99))
+            pts_out, faces_out = fast_simplification.simplify(
+                mesh.vertices, mesh.faces, target_reduction=reduction
             )
-            with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmp:
-                ply_out = tmp.name
-            ms.save_current_mesh(ply_out)
-            lod_mesh = trimesh.load(ply_out, force="mesh")
-            out = CURRENT_LODS / f"LOD{idx}.glb"
+            lod_mesh = trimesh.Trimesh(vertices=pts_out, faces=faces_out, process=False)
             lod_mesh.export(str(out))
-
+            actual_counts.append(len(faces_out))
         lod_paths.append(out)
 
     state = workspace.get_state()
     state.lod_glbs = lod_paths
 
-    counts = [int(base_faces * r) for r in lod_ratios]
-    return lod_paths, f"LODs: {' / '.join(str(c) for c in counts)} faces"
+    return lod_paths, f"LODs: {' / '.join(str(c) for c in actual_counts)} faces"
 
 
 # ---------------------------------------------------------------------------

src/stages/stage2_repair.py

@@ -15,7 +15,7 @@ def repair_mesh(input_glb: Path) -> tuple[Path, str]:
     mesh = trimesh.load(str(input_glb), force="mesh")
     v, f = mesh.vertices.copy(), mesh.faces.copy()
 
-    tin = pymeshfix.PyTMesh(verbose=False)
+    tin = pymeshfix.PyTMesh()   # verbose kwarg removed in pymeshfix ≥ 0.17
     tin.load_array(v, f)
     tin.fill_small_boundaries()
     tin.clean(max_iters=10, inner_loops=3)