Add example

app.py

@@ -71,6 +71,30 @@ BENCH_WIDTHS = [int(x) for x in os.environ.get("BENCH_WIDTHS", "512 768").split(
 ARTIFACTS_DIR = Path(tempfile.gettempdir()) / "dvsm_artifacts"
 ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
 
+# Pre-built example scenes are auto-discovered from examples/: every
+# "<stem>.recon.pt" (baked with THIS model) that has a matching "<stem>.jpg|png"
+# thumbnail becomes a gallery entry. Drop files in / remove them to change the
+# gallery — no code edit needed. Clicking a thumbnail skips reconstruction and
+# opens the live session directly on the artifact.
+EXAMPLES_DIR = PROJECT_ROOT / "examples"
+
+
+def _discover_examples():
+    """Every "<stem>.recon.pt" with a matching "<stem>.jpg|jpeg|png|webp"
+    thumbnail. The gallery shows thumbnails only (no labels)."""
+    scenes = []
+    for recon in sorted(EXAMPLES_DIR.glob("*.recon.pt")):
+        stem = recon.name[: -len(".recon.pt")]
+        thumb = next((EXAMPLES_DIR / f"{stem}{ext}"
+                      for ext in (".jpg", ".jpeg", ".png", ".webp")
+                      if (EXAMPLES_DIR / f"{stem}{ext}").exists()), None)
+        if thumb is not None:
+            scenes.append({"thumb": thumb, "recon": recon})
+    return scenes
+
+
+EXAMPLE_SCENES = _discover_examples()
+
 # ---------------------------------------------------------------------------
 # Module-level model load: download + keep on CPU (ZeroGPU convention).
 # Real `.cuda()` happens inside @spaces.GPU workers.
@@ -150,9 +174,14 @@ class _SessionArgs:
 @spaces.GPU(duration=SESSION_SECONDS)
 def _live_session_worker(artifact_path: str, port: int):
     """Generator running in the GPU worker. Builds the renderer, starts a viser
-    server on `port`, then holds the GPU (yielding heartbeats) until the session
-    budget expires. Each yield is the integer seconds remaining; the first yield
-    signals the viser server is up and serving."""
+    server on `port`, then holds the GPU until the session budget expires.
+
+    Yields tagged tuples so the UI can show a prep progress bar then a live
+    countdown:
+        ("prep",  frac, desc)     during setup
+        ("ready", port, None)     viser is up and serving
+        ("alive", remaining, None) per-second heartbeat while holding the GPU
+    """
     import torch
     import viser
     from dvsm.models.pose_preprocessor import PosePreprocessor
@@ -160,6 +189,7 @@ def _live_session_worker(artifact_path: str, port: int):
     from viser_app.viewer import install_viser_handlers
     from viser_app.viewer_optim import install_optimizations
 
+    yield ("prep", 0.15, "Loading scene…")
     model = DVSM_MODEL_CPU.cuda().eval()
     artifact = torch.load(artifact_path, weights_only=False, map_location="cpu")
     renderer = build_renderer(model, artifact)
@@ -172,24 +202,25 @@ def _live_session_worker(artifact_path: str, port: int):
     renderer.pose_preprocessor = None
     pp_scale = float(pp_cpu.s.reshape(-1)[0])
 
+    yield ("prep", 0.4, "Loading scene…")
     renderer = install_optimizations(
         renderer, use_fast_plucker=True, use_cuda_graph=True,
         n_warmup=5, max_graphs=len(BENCH_WIDTHS) + 2,
     )
 
+    yield ("prep", 0.6, "Loading scene…")
     server = viser.ViserServer(host="0.0.0.0", port=port)
     server.scene.set_up_direction("+y")
     install_viser_handlers(server, renderer, scene_meta, pp_cpu, pp_scale,
                            model, _SessionArgs())
 
     deadline = time.monotonic() + SESSION_SECONDS - 5  # margin before hard kill
-    first = True
+    yield ("ready", port, None)
     while True:
         remaining = int(deadline - time.monotonic())
         if remaining <= 0:
             break
-        yield remaining if not first else 0  # first yield = "ready"
-        first = False
+        yield ("alive", remaining, None)
         time.sleep(1.0)
     try:
         server.stop()
@@ -232,6 +263,21 @@ def _viewer_message(msg: str, color: str = "var(--body-text-color-subdued)") ->
     )
 
 
+def _prep_overlay(frac: float, desc: str) -> str:
+    """Determinate green progress bar centered in the viewer box, shown while
+    the viser session is being prepared (renderer build + warmup + bench)."""
+    pct = max(0, min(100, round(100 * frac)))
+    return (
+        "<div style='width:100%;aspect-ratio:16/9;overflow:hidden;display:flex;"
+        "flex-direction:column;align-items:center;justify-content:center;gap:10px;"
+        "padding:0 12%;color:var(--body-text-color-subdued)'>"
+        f"<div style='font-weight:600;font-size:1.05em'>{desc}</div>"
+        "<div style='width:100%;height:8px;background:#333;border-radius:4px;overflow:hidden'>"
+        f"<div style='height:100%;width:{pct}%;background:#76B900;"
+        "transition:width .3s linear'></div></div></div>"
+    )
+
+
 # ---------------------------------------------------------------------------
 # Gradio callbacks (main process)
 # ---------------------------------------------------------------------------
@@ -339,13 +385,15 @@ def live_session(artifact_path):
     _state["viser_port"] = port
     _state["session_alive"] = True
     try:
-        first = True
-        for remaining in _live_session_worker(artifact_path, port):
-            if first:
-                first = False
+        for tag, a, _b in _live_session_worker(artifact_path, port):
+            if tag == "prep":
+                # a = fraction, _b = description -> prep bar overlaid in the viewer
+                yield (_prep_overlay(a, _b), gr.update())
+            elif tag == "ready":
+                # viser is up -> swap in the iframe + start the countdown bar
                 yield (_iframe_html(port), _session_bar(SESSION_SECONDS, SESSION_SECONDS))
-            else:
-                yield (gr.update(), _session_bar(int(remaining), SESSION_SECONDS))
+            else:  # "alive": a = seconds remaining
+                yield (gr.update(), _session_bar(int(a), SESSION_SECONDS))
     finally:
         _state["session_alive"] = False
         _state["viser_port"] = None
@@ -489,6 +537,11 @@ input[type='range']::-moz-range-thumb     { background: #76B900 !important; }
    sit flush at the column top (kept aligned) and the viewer fills its frame
    edge-to-edge (no padding gap around the iframe). */
 .flush-block { padding: 0 !important; }
+/* Proportional columns: flex-basis 0 so the row width is always split 1:3 and
+   BOTH columns scale with the window (default Gradio scale only distributes the
+   leftover space, leaving the left column looking fixed). */
+.col-left  { flex: 1 1 0 !important; min-width: 260px; }
+.col-right { flex: 3 1 0 !important; min-width: 360px; }
 """
 
 with gr.Blocks(title="TTB-DVSM (ZeroGPU)") as demo:
@@ -533,7 +586,7 @@ with gr.Blocks(title="TTB-DVSM (ZeroGPU)") as demo:
     )
     # Below the text: 1 (inputs + buttons) : 3 (viser viewer).
     with gr.Row():
-        with gr.Column(scale=1, min_width=320):
+        with gr.Column(scale=1, min_width=260, elem_classes=["col-left"]):
             inputs = gr.File(
                 file_count="multiple",
                 file_types=["image", "video", ".mp4", ".mov", ".mkv",
@@ -548,7 +601,19 @@ with gr.Blocks(title="TTB-DVSM (ZeroGPU)") as demo:
             recon_btn = gr.Button("Reconstruct", variant="primary")
             session_btn = gr.Button("Start / Continue Live Session",
                                     variant="primary", interactive=False)
-        with gr.Column(scale=3):
+            if EXAMPLE_SCENES:
+                gr.Markdown("### Example")
+                example_gallery = gr.Gallery(
+                    # No captions. Fixed box height -> vertical scrollbar when
+                    # there are more thumbnails than fit; width still scales with
+                    # the (resizable) column since it's 3 columns.
+                    value=[str(s["thumb"]) for s in EXAMPLE_SCENES],
+                    columns=3, height=200, object_fit="cover",
+                    show_label=False, allow_preview=False,
+                )
+            else:
+                example_gallery = None
+        with gr.Column(scale=3, elem_classes=["col-right"]):
             # Viewer first so its top edge aligns with the upload box on the
             # left (both flush via .flush-block). Recon progress/status overlay
             # the viewer box itself (see reconstruct_cb); only the live-session
@@ -568,6 +633,22 @@ with gr.Blocks(title="TTB-DVSM (ZeroGPU)") as demo:
                       [viewer_html, session_status],
                       show_progress="hidden")
 
+    # Clicking an example thumbnail loads its prebuilt artifact and opens the
+    # live session directly (no reconstruction).
+    if example_gallery is not None:
+        def _on_example_select(evt: gr.SelectData):
+            idx = int(evt.index)
+            if 0 <= idx < len(EXAMPLE_SCENES):
+                return str(EXAMPLE_SCENES[idx]["recon"]), gr.update(interactive=True)
+            return "", gr.update(interactive=False)
+
+        example_gallery.select(
+            _on_example_select, None, [artifact_state, session_btn],
+        ).then(
+            live_session, [artifact_state], [viewer_html, session_status],
+            show_progress="hidden",
+        )
+
 
 # ---------------------------------------------------------------------------
 # Launch Gradio (which starts uvicorn) and attach the viser reverse-proxy routes

viser_app/recon_scene.py

@@ -210,14 +210,17 @@ def reconstruct(ckpt_root: Path | None, ckpt_name: str, scene_data: dict,
 
 
 def _move_kv_to_cpu(kv):
+    """Move baked fast-weights to CPU, storing floating tensors as fp16 to halve
+    the artifact size on disk (upcast back to fp32 at load time, see
+    render._kv_to_cuda)."""
     if kv is None:
         return None
+    if isinstance(kv, torch.Tensor):
+        return kv.half().cpu() if kv.is_floating_point() else kv.cpu()
     if isinstance(kv, dict):
-        return {k: (v.cpu() if isinstance(v, torch.Tensor) else v) for k, v in kv.items()}
+        return {k: _move_kv_to_cpu(v) for k, v in kv.items()}
     if isinstance(kv, (tuple, list)):
         return type(kv)(_move_kv_to_cpu(v) for v in kv)
-    if isinstance(kv, torch.Tensor):
-        return kv.cpu()
     return kv
 
 

viser_app/render.py

@@ -68,14 +68,16 @@ def load_model(ckpt_root: Path | None = None, ckpt_name: str = "latest.pt",
 
 
 def _kv_to_cuda(kv):
+    """Move baked fast-weights to CUDA, upcasting fp16 (how they're stored on
+    disk, see recon_scene._move_kv_to_cpu) back to fp32 for rendering."""
     if kv is None:
         return None
+    if isinstance(kv, torch.Tensor):
+        return (kv.float() if kv.dtype == torch.float16 else kv).cuda()
     if isinstance(kv, dict):
-        return {k: (v.cuda() if isinstance(v, torch.Tensor) else v) for k, v in kv.items()}
+        return {k: _kv_to_cuda(v) for k, v in kv.items()}
     if isinstance(kv, (tuple, list)):
         return type(kv)(_kv_to_cuda(v) for v in kv)
-    if isinstance(kv, torch.Tensor):
-        return kv.cuda()
     return kv