Pointmap: recenter mesh on human centroid; drop floor ring + axes; closer initial camera

app.py

@@ -167,9 +167,9 @@ def _depth_to_rgb(depth: np.ndarray, mask: np.ndarray) -> np.ndarray:
 # -----------------------------------------------------------------------------
 # Point cloud export — trimesh → .glb (much faster than Open3D .ply for Three.js)
 
-def _camera_marker(radius: float = 0.04, n_points: int = 800,
+def _camera_marker(radius: float = 0.025, n_points: int = 600,
                    color=(51, 140, 245)):
-    """Tiny slate-blue Fibonacci sphere at the world origin. Returns (verts, cols)."""
+    """Tiny slate-blue Fibonacci sphere marking the camera. Returns (verts, cols)."""
     i = np.arange(n_points)
     phi = np.arccos(1 - 2 * (i + 0.5) / n_points)
     theta = np.pi * (1 + 5 ** 0.5) * (i + 0.5)
@@ -182,35 +182,6 @@ def _camera_marker(radius: float = 0.04, n_points: int = 800,
     return verts, cols
 
 
-def _xyz_axes(length: float = 0.4, n_per_axis: int = 200):
-    """RGB axes from the origin — X red, Y green, Z blue."""
-    t = np.linspace(0.06, length, n_per_axis, dtype=np.float32)  # start beyond camera marker
-    zeros = np.zeros_like(t)
-    x_pts = np.stack([t, zeros, zeros], axis=1)
-    y_pts = np.stack([zeros, t, zeros], axis=1)
-    z_pts = np.stack([zeros, zeros, t], axis=1)
-    verts = np.concatenate([x_pts, y_pts, z_pts])
-    cols = np.concatenate([
-        np.tile([235, 70, 70, 255],   (n_per_axis, 1)),  # red — X
-        np.tile([70, 200, 100, 255],  (n_per_axis, 1)),  # green — Y
-        np.tile([90, 145, 245, 255],  (n_per_axis, 1)),  # blue — Z (forward = depth)
-    ]).astype(np.uint8)
-    return verts.astype(np.float32), cols
-
-
-def _floor_ring(radius: float = 1.5, n_points: int = 360, y: float = 0.0,
-                color=(140, 145, 160)):
-    """Soft grey horizon ring on the world Y=0 plane — a subtle scale reference."""
-    theta = np.linspace(0, 2 * np.pi, n_points, endpoint=False, dtype=np.float32)
-    verts = np.stack([
-        radius * np.cos(theta),
-        np.full_like(theta, y),
-        radius * np.sin(theta),
-    ], axis=1)
-    cols = np.tile(np.array(color + (180,), dtype=np.uint8), (n_points, 1))
-    return verts, cols
-
-
 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.
@@ -260,12 +231,15 @@ def _make_glb(image_pil_native: Image.Image, pointmap_hwc: np.ndarray,
     flip = np.array([1.0, -1.0, -1.0], dtype=np.float32)
     verts = verts * flip
 
-    # MoGe-style: V flipped (image origin is top-left, GL UVs origin bottom-left).
+    # Recenter the scene on the human's centroid so Three.js's auto-fit
+    # focuses tightly on the figure — without this, the camera marker at the
+    # original world origin (~1-2m behind the human) inflates the bounding
+    # box and the human ends up small in the default view.
+    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 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,
@@ -275,17 +249,12 @@ def _make_glb(image_pil_native: Image.Image, pointmap_hwc: np.ndarray,
     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 (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()
-        aids_v.append(v * flip)
-        aids_c.append(c)
-    aids = trimesh.PointCloud(vertices=np.concatenate(aids_v, axis=0),
-                              colors=np.concatenate(aids_c, axis=0))
+    _ = mesh.vertex_normals  # lazy compute → exported in glb
+
+    # Tiny camera marker only — at the (now-shifted) origin of the camera frame.
+    cam_v, cam_c = _camera_marker()
+    cam_v = cam_v * flip - centroid
+    aids = trimesh.PointCloud(vertices=cam_v, colors=cam_c)
 
     scene = trimesh.Scene([mesh, aids])
     out_path = tempfile.NamedTemporaryFile(delete=False, suffix=".glb").name
@@ -402,7 +371,7 @@ with gr.Blocks(title="Sapiens2 Pointmap", theme=gr.themes.Soft(), css=CUSTOM_CSS
             label="Pointmap",
             height=640,
             clear_color=[0.10, 0.11, 0.14, 1.0],
-            camera_position=(35, 70, 4.0),
+            camera_position=(35, 70, 1.6),  # closer, since scene is centered on the human
             zoom_speed=0.7,
             pan_speed=0.5,
             scale=3,