Pointmap mesh polish: UV-textured PBR (image as albedo) + vertex normals + tighter max_edge=0.02m

app.py

@@ -211,68 +211,74 @@ def _floor_ring(radius: float = 1.5, n_points: int = 360, y: float = 0.0,
     return verts, cols
 
 
-def _triangulate_grid(pointmap_hwc: np.ndarray, image_rgb: np.ndarray,
-                      mask_hw: np.ndarray, max_edge: float = 0.05):
+def _triangulate_grid(pointmap_hwc: np.ndarray, mask_hw: np.ndarray,
+                      max_edge: float = 0.02):
     """Build a triangulated mesh from the (H, W) pointmap grid.
 
-    Each valid pixel becomes a vertex; adjacent valid pixels form quads
-    (two triangles). Triangles whose edges exceed `max_edge` (meters) are
-    dropped so we don't stretch skin between the subject and the background.
+    Returns (verts, uvs, faces). Each valid pixel becomes a vertex; adjacent
+    valid pixels form quads (2 tris). Triangles with any edge longer than
+    `max_edge` (meters) are dropped to kill stretched skin at depth jumps.
+    UVs are pixel-aligned for direct texturing with the input image.
     """
     H, W = pointmap_hwc.shape[:2]
     z = pointmap_hwc[:, :, 2]
     valid = mask_hw & np.isfinite(pointmap_hwc).all(axis=2) & (z > 0.05) & (z < 25.0)
 
-    # Vertex index per pixel; -1 if invalid.
     idx_map = np.full((H, W), -1, dtype=np.int64)
     yy, xx = np.where(valid)
     idx_map[yy, xx] = np.arange(len(yy))
 
-    verts = pointmap_hwc[yy, xx]                         # (N, 3) float32
-    cols = image_rgb[yy, xx]                             # (N, 3) uint8
+    verts = pointmap_hwc[yy, xx].astype(np.float32)              # (N, 3)
+    uvs = np.stack([xx / max(W - 1, 1), yy / max(H - 1, 1)],
+                   axis=1).astype(np.float32)                    # (N, 2)
 
-    # Quad corners
-    a = idx_map[:-1, :-1]   # top-left
-    b = idx_map[:-1, 1:]    # top-right
-    c = idx_map[1:, :-1]    # bottom-left
-    d = idx_map[1:, 1:]     # bottom-right
+    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)             # (M, 3)
-    tri2 = np.stack([b_v, c_v, d_v], axis=1)             # (M, 3)
-    faces = np.concatenate([tri1, tri2], axis=0)          # (2M, 3)
-
-    # Drop triangles with any edge longer than max_edge — kills stretched skins.
-    p0 = verts[faces[:, 0]]
-    p1 = verts[faces[:, 1]]
-    p2 = verts[faces[:, 2]]
+    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]
-
-    return verts.astype(np.float32), cols.astype(np.uint8), faces.astype(np.int64)
+    faces = faces[keep].astype(np.int64)
+    return verts, uvs, faces
 
 
 def _make_glb(image_pil_native: Image.Image, pointmap_hwc: np.ndarray,
-              mask_hw: np.ndarray) -> str:
+              mask_hw: np.ndarray, max_edge: float = 0.02) -> str:
     h, w = pointmap_hwc.shape[:2]
-    image_rgb = np.asarray(image_pil_native.resize((w, h), Image.LANCZOS))
+    image_native = image_pil_native.resize((w, h), Image.LANCZOS)
 
-    verts, cols_rgb, faces = _triangulate_grid(pointmap_hwc, image_rgb, mask_hw)
+    verts, uvs, faces = _triangulate_grid(pointmap_hwc, mask_hw, max_edge=max_edge)
 
     # Y-up flip so the viewer's default orientation matches photographic intuition.
     flip = np.array([1.0, -1.0, -1.0], dtype=np.float32)
     verts = verts * flip
 
-    cols_rgba = np.concatenate(
-        [cols_rgb, np.full((len(cols_rgb), 1), 255, dtype=np.uint8)], axis=1
+    # MoGe-style: V flipped (image origin is top-left, GL UVs origin bottom-left).
+    uvs = uvs * np.array([1.0, -1.0], dtype=np.float32) + np.array([0.0, 1.0], dtype=np.float32)
+
+    # PBR material with the input image as the albedo texture — much sharper than
+    # vertex colors because each triangle interior is sampled from the image at
+    # the correct pixel, not bilinearly between 3 corner colors.
+    material = trimesh.visual.material.PBRMaterial(
+        baseColorTexture=image_native,
+        metallicFactor=0.0,
+        roughnessFactor=1.0,
+        doubleSided=True,
     )
-    mesh = trimesh.Trimesh(vertices=verts, faces=faces, vertex_colors=cols_rgba, process=False)
+    visual = trimesh.visual.texture.TextureVisuals(uv=uvs, material=material)
+
+    mesh = trimesh.Trimesh(vertices=verts, faces=faces, visual=visual, process=False)
+    # Compute and attach per-vertex normals → enables shading in Three.js viewer.
+    _ = mesh.vertex_normals  # triggers lazy compute; trimesh exports them in glb
 
-    # Scene aids as separate point clouds.
+    # Scene aids (camera marker, XYZ axes, floor ring) as a single point primitive.
     aids_v, aids_c = [], []
     for fn in (_camera_marker, _xyz_axes, _floor_ring):
         v, c = fn()