Pointmap: switch back to spheres (KHR_materials_unlit injection makes them flat-coloured)

app.py

@@ -236,93 +236,52 @@ 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 = 80_000) -> str:
-    """Render the pointmap as **surfels** — each pixel becomes a small flat
-    quad oriented along the surface normal at that point. No triangulation
-    BETWEEN points (so no triangle artifacts), but each surfel still tiles
-    the surface, giving a smooth "skin" appearance instead of granular balls.
-
-    4 verts + 2 faces per surfel → much lighter than spheres (~1/10 the verts).
-    """
+              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."""
     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)
-
-    # Smooth per-pixel normals from the pointmap's spatial gradient.
-    px = np.zeros_like(pointmap_hwc, dtype=np.float32)
-    py = np.zeros_like(pointmap_hwc, dtype=np.float32)
-    px[:, 1:-1] = (pointmap_hwc[:, 2:] - pointmap_hwc[:, :-2]) * 0.5
-    py[1:-1, :] = (pointmap_hwc[2:, :] - pointmap_hwc[:-2, :]) * 0.5
-    n_grid = np.cross(px, py)
-    n_grid /= np.linalg.norm(n_grid, axis=2, keepdims=True).clip(min=1e-8)
-
     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]
 
     pts = pointmap_hwc[yy, xx].astype(np.float32)
-    nrm = n_grid[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)
 
     flip = np.array([1.0, -1.0, -1.0], dtype=np.float32)
     pts = pts * flip
-    nrm = nrm * flip
     centroid = pts.mean(axis=0).astype(np.float32) if len(pts) else np.zeros(3, np.float32)
     pts = pts - centroid
 
-    # Surfel size: surface-spacing estimate = bbox diagonal / sqrt(N).
-    # This is geometrically correct for points distributed across a 2D surface;
-    # raw KD-tree NN distance is biased too small (adjacent pixels often map
-    # to nearly-coincident 3D points, pulling the median way below the actual
-    # visual spacing). Factor 1.5 gives clear overlap so the surface reads
-    # as solid skin rather than a sparse tile pattern.
+    # 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)) * 1.5, 1e-4)
     else:
         r = 0.005
 
-    # Tangent basis (u, v) per surfel, perpendicular to that surfel's normal.
-    up = np.array([0.0, 1.0, 0.0], dtype=np.float32)
-    u = np.cross(nrm, up)                                      # (N, 3)
-    u_norm = np.linalg.norm(u, axis=1, keepdims=True)
-    # Fallback for any normals nearly parallel to "up".
-    parallel = (u_norm.squeeze(-1) < 1e-4)
-    if parallel.any():
-        ref = np.array([1.0, 0.0, 0.0], dtype=np.float32)
-        u[parallel] = np.cross(nrm[parallel], ref)
-        u_norm[parallel] = np.linalg.norm(u[parallel], axis=1, keepdims=True).clip(min=1e-8)
-    u = u / u_norm.clip(min=1e-8)
-    v = np.cross(nrm, u)                                       # (N, 3) — already unit
-
-    # 4 corners per surfel (CCW when viewed from +normal):
-    #   0 = P − r*u − r*v
-    #   1 = P + r*u − r*v
-    #   2 = P + r*u + r*v
-    #   3 = P − r*u + r*v
-    ru, rv = r * u, r * v
-    c0 = pts - ru - rv
-    c1 = pts + ru - rv
-    c2 = pts + ru + rv
-    c3 = pts - ru + rv
-    verts = np.stack([c0, c1, c2, c3], axis=1).reshape(-1, 3).astype(np.float32)
-
-    # 2 triangles per surfel: (0,1,2) and (0,2,3), offset by 4 per surfel.
+    # 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)
-    base = (np.arange(N, dtype=np.int64) * 4)[:, None, None]
-    tri = np.array([[0, 1, 2], [0, 2, 3]], dtype=np.int64)[None, :, :]
-    faces = (base + tri).reshape(-1, 3)
 
-    # Uniform colour across each surfel's 4 verts.
-    vc = np.empty((N, 4, 4), dtype=np.uint8)
+    # 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)
 
-    # Plain vertex colors only — no PBR material customization, no normals,
-    # nothing that would inject lighting variation between surfels.
     mesh = trimesh.Trimesh(
         vertices=verts, faces=faces,
         vertex_colors=vertex_colors,
@@ -330,7 +289,7 @@ def _make_glb(image_pil_texture: Image.Image, pointmap_hwc: np.ndarray,
     )
     out_path = tempfile.NamedTemporaryFile(delete=False, suffix=".glb").name
     mesh.export(out_path)
-    _glb_inject_unlit(out_path)   # → render with raw vertex color, no lighting
+    _glb_inject_unlit(out_path)   # → flat-coloured balls, no shading
     return out_path