Perf: binary PLY, downsample input, subsample 200k points max

app.py

@@ -47,12 +47,17 @@ def _run_depth_inference(image: Image.Image):
 # =====================================================================
 @spaces.GPU(duration=120)
 def create_3d_point_cloud(input_pil_image):
-    """Processes the image, calculates 3D vertices, and writes a .ply file."""
+    """Processes the image, calculates 3D vertices, and writes a binary .ply file."""
     if input_pil_image is None:
         return None
 
-    # Step A: Depth inference
+    # Step A: Downscale large images before inference.
+    # DepthPro quality is stable at 512px; this dramatically cuts runtime.
     image = input_pil_image.convert("RGB")
+    MAX_DIM = 512
+    if max(image.width, image.height) > MAX_DIM:
+        image.thumbnail((MAX_DIM, MAX_DIM), Image.LANCZOS)
+
     post_processed = _run_depth_inference(image)
     depth_matrix = (
         post_processed[0]["predicted_depth"]
@@ -61,11 +66,12 @@ def create_3d_point_cloud(input_pil_image):
 
     # Step B: Pinhole camera projection (u, v, depth) -> (X, Y, Z)
     height, width = depth_matrix.shape
-    color_np = np.array(image) / 255.0
+    color_np = np.array(image, dtype=np.float32) / 255.0
 
-    focal_length = max(width, height)
+    focal_length = float(max(width, height))
     cx, cy = width / 2.0, height / 2.0
-    u, v = np.meshgrid(np.arange(width), np.arange(height))
+    u, v = np.meshgrid(np.arange(width, dtype=np.float32),
+                        np.arange(height, dtype=np.float32))
 
     z = depth_matrix.flatten()
     x = ((u.flatten() - cx) * z) / focal_length
@@ -74,31 +80,46 @@ def create_3d_point_cloud(input_pil_image):
     # Keep objects between 10 cm and 30 m; discard sky / infinite background
     valid_mask = (z > 0.1) & (z < 30.0)
     x, y, z = x[valid_mask], y[valid_mask], z[valid_mask]
+    rgb_ints = (color_np.reshape(-1, 3)[valid_mask] * 255).astype(np.uint8)
 
-    rgb = color_np.reshape(-1, 3)[valid_mask]
-    rgb_ints = (rgb * 255).astype(np.uint8)
+    # Step C: Subsample to keep the browser renderer fast (<= 200k points)
+    MAX_POINTS = 200_000
+    if len(z) > MAX_POINTS:
+        idx = np.random.choice(len(z), MAX_POINTS, replace=False)
+        x, y, z = x[idx], y[idx], z[idx]
+        rgb_ints = rgb_ints[idx]
 
-    # Step C: Write ASCII PLY file
-    ply_filename = "output_scene.ply"
+    # Step D: Write BINARY PLY via numpy (100x faster than an ASCII for-loop)
     num_points = len(z)
+    vertex_dtype = np.dtype([
+        ('x', '<f4'), ('y', '<f4'), ('z', '<f4'),
+        ('red', 'u1'), ('green', 'u1'), ('blue', 'u1'),
+    ])
+    vertices = np.empty(num_points, dtype=vertex_dtype)
+    vertices['x']     = x.astype(np.float32)
+    vertices['y']     = (-y).astype(np.float32)   # invert Y so it loads right-side up
+    vertices['z']     = z.astype(np.float32)
+    vertices['red']   = rgb_ints[:, 0]
+    vertices['green'] = rgb_ints[:, 1]
+    vertices['blue']  = rgb_ints[:, 2]
+
+    ply_header = (
+        "ply\n"
+        "format binary_little_endian 1.0\n"
+        f"element vertex {num_points}\n"
+        "property float x\n"
+        "property float y\n"
+        "property float z\n"
+        "property uchar red\n"
+        "property uchar green\n"
+        "property uchar blue\n"
+        "end_header\n"
+    )
 
-    with open(ply_filename, "w") as f:
-        f.write("ply\n")
-        f.write("format ascii 1.0\n")
-        f.write(f"element vertex {num_points}\n")
-        f.write("property float x\n")
-        f.write("property float y\n")
-        f.write("property float z\n")
-        f.write("property uchar red\n")
-        f.write("property uchar green\n")
-        f.write("property uchar blue\n")
-        f.write("end_header\n")
-        for i in range(num_points):
-            # Invert Y axis so the model loads right-side up
-            f.write(
-                f"{x[i]:.4f} {-y[i]:.4f} {z[i]:.4f} "
-                f"{rgb_ints[i][0]} {rgb_ints[i][1]} {rgb_ints[i][2]}\n"
-            )
+    ply_filename = "/tmp/output_scene.ply"
+    with open(ply_filename, "wb") as f:
+        f.write(ply_header.encode("ascii"))
+        f.write(vertices.tobytes())
 
     return ply_filename