Pointmap: switch back to triangulated mesh — MoGe-2 recipe (UV-textured PBR, smooth normals via lazy compute)

app.py

@@ -236,60 +236,70 @@ def _triangulate_grid(pointmap_hwc: np.ndarray, mask_hw: np.ndarray,
 
 
 def _make_glb(image_pil_texture: Image.Image, pointmap_hwc: np.ndarray,
-              mask_hw: np.ndarray, max_points: int = 25_000) -> str:
-    """Render the pointmap as a cloud of small icospheres — one per pixel,
-    coloured by the source image. With KHR_materials_unlit injected post-
-    export, each ball renders as a flat-coloured 3D primitive (no lighting
-    variation), giving a clean "candy ball cloud" surface."""
+              mask_hw: np.ndarray, max_edge: float = 0.04) -> str:
+    """Triangulated mesh, UV-textured with the input image — MoGe-2's recipe.
+
+    Each valid pixel = vertex; adjacent valid pixels form quads → 2 triangles.
+    Triangles whose edges exceed `max_edge` (meters) are dropped to kill
+    stretched skin at depth jumps. The input image is used as the GLB's albedo
+    texture (per-triangle PBR sampling), and trimesh's lazy vertex_normals get
+    exported so Three.js applies smooth shading instead of flat facets.
+    """
     H, W = pointmap_hwc.shape[:2]
+    image_native = image_pil_texture.resize((W, H), Image.LANCZOS)
+
+    # Triangulate the (H, W) grid over the foreground mask.
     z = pointmap_hwc[:, :, 2]
     valid = mask_hw & np.isfinite(pointmap_hwc).all(axis=2) & (z > 0.05) & (z < 25.0)
+    idx_map = np.full((H, W), -1, dtype=np.int64)
     yy, xx = np.where(valid)
-    if len(yy) > max_points:
-        idx = np.random.default_rng(0).choice(len(yy), max_points, replace=False)
-        yy, xx = yy[idx], xx[idx]
+    idx_map[yy, xx] = np.arange(len(yy))
 
-    pts = pointmap_hwc[yy, xx].astype(np.float32)
-    image_native = np.asarray(image_pil_texture.resize((W, H), Image.LANCZOS))
-    cols = image_native[yy, xx].astype(np.uint8)
+    verts = pointmap_hwc[yy, xx].astype(np.float32)
+    uvs = np.stack([xx / max(W - 1, 1), yy / max(H - 1, 1)], axis=1).astype(np.float32)
 
+    a = idx_map[:-1, :-1]; b = idx_map[:-1, 1:]
+    c = idx_map[1:, :-1];  d = idx_map[1:, 1:]
+    quad_valid = (a != -1) & (b != -1) & (c != -1) & (d != -1)
+    a_v, b_v, c_v, d_v = a[quad_valid], b[quad_valid], c[quad_valid], d[quad_valid]
+    tri1 = np.stack([a_v, c_v, b_v], axis=1)
+    tri2 = np.stack([b_v, c_v, d_v], axis=1)
+    faces = np.concatenate([tri1, tri2], axis=0)
+
+    p0 = verts[faces[:, 0]]; p1 = verts[faces[:, 1]]; p2 = verts[faces[:, 2]]
+    e01 = np.linalg.norm(p1 - p0, axis=1)
+    e12 = np.linalg.norm(p2 - p1, axis=1)
+    e20 = np.linalg.norm(p0 - p2, axis=1)
+    keep = (e01 < max_edge) & (e12 < max_edge) & (e20 < max_edge)
+    faces = faces[keep].astype(np.int64)
+
+    # MoGe-2: y/z flip on positions, v-flip on UVs.
     flip = np.array([1.0, -1.0, -1.0], dtype=np.float32)
-    pts = pts * flip
-    centroid = pts.mean(axis=0).astype(np.float32) if len(pts) else np.zeros(3, np.float32)
-    pts = pts - centroid
-
-    # Sphere radius: surface-spacing estimate = bbox diagonal / sqrt(N).
-    # Factor 1.0 → balls just kiss neighbours; 1.5 → distinct overlap.
-    if len(pts) >= 2:
-        extent_diag = float(np.linalg.norm(np.ptp(pts, axis=0)))
-        r = max(extent_diag / np.sqrt(len(pts)) * 0.5, 1e-4)
-    else:
-        r = 0.005
-
-    # Smooth icosphere template (subdivisions=1 → 42 verts, 80 faces).
-    sphere = trimesh.creation.icosphere(subdivisions=1, radius=r)
-    sv = sphere.vertices.astype(np.float32)
-    sf = sphere.faces.astype(np.int64)
-    V, F = len(sv), len(sf)
-    N = len(pts)
-
-    # Vectorized instancing: place a sphere at every point.
-    verts = (sv[None, :, :] + pts[:, None, :]).reshape(-1, 3)
-    face_off = (np.arange(N, dtype=np.int64) * V)[:, None, None]
-    faces = (sf[None, :, :] + face_off).reshape(-1, 3)
-    vc = np.empty((N, V, 4), dtype=np.uint8)
-    vc[..., :3] = cols[:, None, :]
-    vc[..., 3] = 255
-    vertex_colors = vc.reshape(-1, 4)
+    verts = verts * flip
+    centroid = verts.mean(axis=0).astype(np.float32) if len(verts) else np.zeros(3, np.float32)
+    verts = verts - centroid
+
+    uvs = uvs * np.array([1.0, -1.0], dtype=np.float32) + np.array([0.0, 1.0], dtype=np.float32)
+
+    # PBR with image as albedo texture — MoGe's exact material settings.
+    material = trimesh.visual.material.PBRMaterial(
+        baseColorTexture=image_native,
+        metallicFactor=0.5,
+        roughnessFactor=1.0,
+        doubleSided=True,
+    )
+    visual = trimesh.visual.texture.TextureVisuals(uv=uvs, material=material)
 
     mesh = trimesh.Trimesh(
-        vertices=verts, faces=faces,
-        vertex_colors=vertex_colors,
-        process=False,
+        vertices=verts, faces=faces, visual=visual, process=False,
     )
+    # Touch vertex_normals so trimesh caches them; the GLB exporter reads
+    # the cached normals and writes them into the file → smooth shading
+    # in Three.js (instead of the per-face fallback that looked like facets).
+    _ = mesh.vertex_normals
+
     out_path = tempfile.NamedTemporaryFile(delete=False, suffix=".glb").name
     mesh.export(out_path)
-    _glb_inject_unlit(out_path)   # → flat-coloured balls, no shading
     return out_path