Add CPU texture-bake fallback: xatlas UV-unwrap + numpy projection

nvdiffrast fails on ZeroGPU A10G with error 209 (cudaErrorInvalidDeviceFunction)
for both GL and CUDA contexts. Add _bake_texture_cpu() that uses:
- xatlas for UV parametrization (no GPU required)
- Per-face orthographic projection from the 6 MV-Adapter views
- trimesh for GLB export with embedded texture

The primary nvdiffrast path is tried first; on any exception the CPU
fallback runs automatically. Also add xatlas to requirements.txt.

app.py

@@ -905,6 +905,123 @@ def generate_shape(input_image, remove_background, num_steps, guidance_scale,
         return None, f"Error:\n{traceback.format_exc()}"
 
 
+# ── CPU texture-bake fallback (no nvdiffrast) ─────────────────────────────────
+
+def _bake_texture_cpu(glb_path: str, mv_views: list, out_path: str,
+                      uv_size: int = 1024) -> str:
+    """
+    CPU texture baking via xatlas UV-unwrap + per-face numpy projection.
+    Used when CameraProjection / nvdiffrast is unavailable (error 209 on ZeroGPU).
+    """
+    import xatlas
+    import trimesh as _trimesh
+
+    print("[_bake_texture_cpu] Loading mesh...")
+    scene = _trimesh.load(glb_path)
+    if isinstance(scene, _trimesh.Scene):
+        parts = [g for g in scene.geometry.values() if isinstance(g, _trimesh.Trimesh)]
+        mesh  = _trimesh.util.concatenate(parts) if len(parts) > 1 else parts[0]
+    else:
+        mesh = scene
+
+    verts = np.array(mesh.vertices, dtype=np.float32)
+    faces = np.array(mesh.faces,    dtype=np.uint32)
+
+    # Normalize to camera projection space (coords ≈ ±0.55)
+    center  = (verts.max(0) + verts.min(0)) * 0.5
+    scale   = (verts.max(0) - verts.min(0)).max() / 1.1
+    verts_n = (verts - center) / scale
+
+    print("[_bake_texture_cpu] Running xatlas UV parametrize...")
+    vmapping, new_faces, uvs = xatlas.parametrize(verts_n, faces)
+    verts_new = verts_n[vmapping]   # (N_new, 3)
+
+    v0  = verts_new[new_faces[:, 0]]; uv0 = uvs[new_faces[:, 0]]
+    v1  = verts_new[new_faces[:, 1]]; uv1 = uvs[new_faces[:, 1]]
+    v2  = verts_new[new_faces[:, 2]]; uv2 = uvs[new_faces[:, 2]]
+
+    # Face normals
+    normals   = np.cross(v1 - v0, v2 - v0)
+    norms_len = np.linalg.norm(normals, axis=1, keepdims=True)
+    valid     = norms_len[:, 0] > 1e-8
+    normals[valid] /= norms_len[valid]
+
+    # 6 cameras: azimuth = [-90,-45,0,90,180,225] deg (matches MV-Adapter setup)
+    azims    = np.radians(np.array([-90., -45., 0., 90., 180., 225.]))
+    cam_dirs = np.stack([np.sin(azims), np.zeros(6), np.cos(azims)], axis=1)
+    dots      = normals @ cam_dirs.T   # (F, 6)
+    best_view = dots.argmax(1)
+    max_dot   = dots.max(1)
+
+    view_imgs = [np.array(v.resize((768, 768)))[..., :3] for v in mv_views]
+
+    print(f"[_bake_texture_cpu] Baking {len(new_faces)} faces into {uv_size}x{uv_size} texture...")
+    tex = np.full((uv_size, uv_size, 3), 200, dtype=np.uint8)
+
+    for fi in range(len(new_faces)):
+        if not valid[fi] or max_dot[fi] < 0.05:
+            continue
+
+        bv = int(best_view[fi])
+        az = float(azims[bv])
+
+        uv_tri = np.stack([uv0[fi], uv1[fi], uv2[fi]])
+        px     = uv_tri * (uv_size - 1)
+        u_min  = max(0,         int(np.floor(px[:, 0].min())))
+        u_max  = min(uv_size-1, int(np.ceil (px[:, 0].max())))
+        v_min  = max(0,         int(np.floor(px[:, 1].min())))
+        v_max  = min(uv_size-1, int(np.ceil (px[:, 1].max())))
+        if u_max < u_min or v_max < v_min:
+            continue
+
+        pu = np.arange(u_min, u_max + 1, dtype=np.float32) / (uv_size - 1)
+        pv = np.arange(v_min, v_max + 1, dtype=np.float32) / (uv_size - 1)
+        PU, PV = np.meshgrid(pu, pv)
+        P      = np.stack([PU.ravel(), PV.ravel()], axis=1)
+
+        d1    = uv1[fi] - uv0[fi]
+        d2    = uv2[fi] - uv0[fi]
+        dp    = P - uv0[fi]
+        denom = d1[0] * d2[1] - d1[1] * d2[0]
+        if abs(denom) < 1e-10:
+            continue
+        b1 = (dp[:, 0] * d2[1] - dp[:, 1] * d2[0]) / denom
+        b2 = (d1[0] * dp[:, 1] - d1[1] * dp[:, 0]) / denom
+        b0 = 1.0 - b1 - b2
+        inside = (b0 >= -0.01) & (b1 >= -0.01) & (b2 >= -0.01)
+        if not inside.any():
+            continue
+
+        b0i = b0[inside, None]; b1i = b1[inside, None]; b2i = b2[inside, None]
+        p3d = b0i * v0[fi] + b1i * v1[fi] + b2i * v2[fi]
+
+        right = np.array([ np.cos(az), 0.0, -np.sin(az)])
+        up    = np.array([ 0.0,         1.0,  0.0       ])
+        u_cam = np.clip(p3d @ right / 1.1 * 0.5 + 0.5,          0.0, 1.0)
+        v_cam = np.clip(1.0 - (p3d @ up   / 1.1 * 0.5 + 0.5),   0.0, 1.0)
+        u_img = (u_cam * 767).astype(np.int32)
+        v_img = (v_cam * 767).astype(np.int32)
+
+        colors = view_imgs[bv][v_img, u_img]
+
+        pu_in = np.round(PU.ravel()[inside] * (uv_size - 1)).astype(np.int32)
+        pv_in = np.round(PV.ravel()[inside] * (uv_size - 1)).astype(np.int32)
+        tex[pv_in, pu_in] = colors
+
+    print("[_bake_texture_cpu] Saving textured GLB...")
+    new_mesh = _trimesh.Trimesh(
+        vertices = verts_new,
+        faces    = new_faces.astype(np.int64),
+        visual   = _trimesh.visual.TextureVisuals(
+            uv    = uvs,
+            image = Image.fromarray(tex),
+        ),
+        process=False,
+    )
+    new_mesh.export(out_path)
+    return out_path
+
+
 # ── Stage 2: Texture ──────────────────────────────────────────────────────────
 
 @spaces.GPU(duration=300)
@@ -1025,54 +1142,54 @@ def apply_texture(glb_path, input_image, remove_background, variant, tex_seed,
                 print(f"[apply_texture] face enhance failed: {_fe}")
 
         # ── Bake textures onto mesh ─────────────────────────────────────
-        # Use CameraProjection + replace_mesh_texture_and_save directly.
-        # TexturePipeline imports mesh_process which requires open3d+pymeshlab
-        # (not available); the UV projection itself has no such dependency.
         progress(0.85, desc="Baking UV texture onto mesh...")
-        from mvadapter.utils.mesh_utils import (
-            load_mesh, replace_mesh_texture_and_save,
-        )
-        from mvadapter.utils.mesh_utils.projection import CameraProjection
-        from mvadapter.utils import image_to_tensor, tensor_to_image
 
         # Split the saved horizontal 6-view grid back into individual images
-        mv_img = Image.open(mv_path)
-        mv_np  = np.array(mv_img)
-        mv_views  = [Image.fromarray(v) for v in np.array_split(mv_np, 6, axis=1)]
-
-        # Cameras must match those used during MV-Adapter generation
-        tex_cameras = get_orthogonal_camera(
-            elevation_deg=[0, 0, 0, 0, 0, 0],
-            distance=[1.8] * 6,
-            left=-0.55, right=0.55, bottom=-0.55, top=0.55,
-            azimuth_deg=[x - 90 for x in [0, 45, 90, 180, 270, 315]],
-            device=DEVICE,
-        )
-        mesh_obj  = load_mesh(glb_path, rescale=True, device=DEVICE, default_uv_size=1024)
-        cam_proj  = CameraProjection(pb_backend="torch-cuda", bg_remover=None, device=DEVICE, context_type="cuda")
-        mod_tensor = image_to_tensor(mv_views, device=DEVICE)
-
-        cam_out = cam_proj(
-            mod_tensor, mesh_obj, tex_cameras,
-            from_scratch=True,
-            poisson_blending=False,
-            depth_grad_dilation=5,
-            depth_grad_threshold=0.1,
-            uv_exp_blend_alpha=3,
-            uv_exp_blend_view_weight=torch.as_tensor([1, 1, 1, 1, 1, 1]),
-            aoi_cos_valid_threshold=0.2,
-            uv_size=1024,
-            uv_padding=True,
-            return_dict=True,
-        )
+        mv_img   = Image.open(mv_path)
+        mv_np    = np.array(mv_img)
+        mv_views = [Image.fromarray(v) for v in np.array_split(mv_np, 6, axis=1)]
 
         out_glb = os.path.join(out_dir, "textured_shaded.glb")
-        replace_mesh_texture_and_save(
-            glb_path, out_glb,
-            texture=tensor_to_image(cam_out.uv_proj),
-            backend="gltflib",
-            task_id="textured",
-        )
+        try:
+            # Primary path: CameraProjection via nvdiffrast
+            from mvadapter.utils.mesh_utils import (
+                load_mesh, replace_mesh_texture_and_save,
+            )
+            from mvadapter.utils.mesh_utils.projection import CameraProjection
+            from mvadapter.utils import image_to_tensor, tensor_to_image
+
+            tex_cameras = get_orthogonal_camera(
+                elevation_deg=[0, 0, 0, 0, 0, 0],
+                distance=[1.8] * 6,
+                left=-0.55, right=0.55, bottom=-0.55, top=0.55,
+                azimuth_deg=[x - 90 for x in [0, 45, 90, 180, 270, 315]],
+                device=DEVICE,
+            )
+            mesh_obj   = load_mesh(glb_path, rescale=True, device=DEVICE, default_uv_size=1024)
+            cam_proj   = CameraProjection(pb_backend="torch-cuda", bg_remover=None,
+                                          device=DEVICE, context_type="cuda")
+            mod_tensor = image_to_tensor(mv_views, device=DEVICE)
+
+            cam_out = cam_proj(
+                mod_tensor, mesh_obj, tex_cameras,
+                from_scratch=True, poisson_blending=False,
+                depth_grad_dilation=5, depth_grad_threshold=0.1,
+                uv_exp_blend_alpha=3,
+                uv_exp_blend_view_weight=torch.as_tensor([1, 1, 1, 1, 1, 1]),
+                aoi_cos_valid_threshold=0.2,
+                uv_size=1024, uv_padding=True, return_dict=True,
+            )
+            replace_mesh_texture_and_save(
+                glb_path, out_glb,
+                texture=tensor_to_image(cam_out.uv_proj),
+                backend="gltflib", task_id="textured",
+            )
+            print("[apply_texture] nvdiffrast texture baking succeeded.")
+        except Exception as _nv_err:
+            # Fallback: CPU xatlas UV-unwrap + per-face numpy projection
+            print(f"[apply_texture] nvdiffrast baking failed ({type(_nv_err).__name__}): {_nv_err}")
+            print("[apply_texture] Falling back to CPU xatlas texture bake...")
+            _bake_texture_cpu(glb_path, mv_views, out_glb)
 
         final_path = "/tmp/triposg_textured.glb"
         shutil.copy(out_glb, final_path)

requirements.txt

@@ -31,6 +31,7 @@ trimesh
 fast-simplification
 open3d  # needed by mvadapter pipeline_texture.py (Space runs Python 3.10 which has wheels)
 # pymeshlab: no Python 3.13 wheels — not used in this Space
+xatlas   # CPU UV unwrap fallback for texture baking when nvdiffrast unavailable
 pygltflib
 # pyrender: no Python 3.13 wheels — not used in this Space
 moderngl