Update app.py

app.py

@@ -14,34 +14,20 @@ import spaces
 import torch
 from PIL import Image
 from pillow_heif import register_heif_opener
-import matplotlib.pyplot as plt
 
-# Try to import from both known paths to ensure compatibility depending on MapAnything version
-try:
-    from mapanything.utils.hf_utils.viz import predictions_to_glb
-except ImportError:
-    from mapanything.utils.hf_utils.visual_util import predictions_to_glb
+register_heif_opener()
+sys.path.append("mapanything/")
 
 from mapanything.utils.geometry import depthmap_to_world_frame, points_to_normals
-from mapanything.utils.hf_utils.css_and_html import (
-    get_gradio_theme,
-    GRADIO_CSS,
-)
-# Use a default string if MEASURE_INSTRUCTIONS_HTML is missing in older versions
-try:
-    from mapanything.utils.hf_utils.css_and_html import MEASURE_INSTRUCTIONS_HTML
-except ImportError:
-    MEASURE_INSTRUCTIONS_HTML = "**Measurement:** Click any two points on the image to measure the 3D distance between them."
-
+from mapanything.utils.hf_utils.css_and_html import GRADIO_CSS, get_gradio_theme
 from mapanything.utils.hf_utils.hf_helpers import initialize_mapanything_model
+from mapanything.utils.hf_utils.viz import predictions_to_glb
 from mapanything.utils.image import load_images, rgb
 
-register_heif_opener()
-sys.path.append("mapanything/")
-
 # ============================================================================
 # Global Configuration
 # ============================================================================
+
 high_level_config = {
     "path": "configs/train.yaml",
     "hf_model_name": "facebook/map-anything",
@@ -64,16 +50,28 @@ high_level_config = {
 model = None
 
 # ============================================================================
-# Core Model Inference
+# Measure Instructions (inline definition)
+# ============================================================================
+
+MEASURE_INSTRUCTIONS = """
+**📏 How to Measure:**
+1. **Click** on the image to place **Point 1** — its depth will be shown.
+2. **Click** again to place **Point 2** — the 3D Euclidean distance between the two points is computed automatically.
+3. After measuring, both points reset so you can measure again.
+- Grey-overlay areas have no valid depth — clicks there are ignored.
+"""
+
+# ============================================================================
+# Core Model Inference (Raw 3D — kept exactly as original)
 # ============================================================================
+
+
 @spaces.GPU(duration=120)
-def run_model(
-    target_dir,
-    apply_mask=True,
-    filter_black_bg=False,
-    filter_white_bg=False,
-):
-    """Run the MapAnything model and prepare output formats."""
+def run_model(target_dir, apply_mask=True):
+    """
+    Run the MapAnything model.
+    Returns predictions dict (numpy arrays).
+    """
     global model
     import torch
 
@@ -101,7 +99,10 @@ def run_model(
 
     print("Running 3D reconstruction...")
     outputs = model.infer(
-        views, apply_mask=apply_mask, mask_edges=True, memory_efficient_inference=False
+        views,
+        apply_mask=apply_mask,
+        mask_edges=True,
+        memory_efficient_inference=False,
     )
 
     predictions = {}
@@ -152,20 +153,20 @@ def run_model(
     predictions["images"] = np.stack(images_list, axis=0)
     predictions["final_mask"] = np.stack(final_mask_list, axis=0)
 
-    # Prepare data for new tabs
-    processed_data = process_predictions_for_visualization(
-        predictions, views, high_level_config, filter_black_bg, filter_white_bg
-    )
-
     torch.cuda.empty_cache()
-    return predictions, processed_data
+    return predictions
 
 
 # ============================================================================
-# Helper Functions (Visualization Logic)
+# Visualization Helpers — Depth / Normal / Measure
 # ============================================================================
+
+
 def colorize_depth(depth_map, mask=None):
-    if depth_map is None: return None
+    """Convert a depth map to a turbo-coloured uint8 image."""
+    if depth_map is None:
+        return None
+
     depth_normalized = depth_map.copy()
     valid_mask = depth_normalized > 0
 
@@ -176,34 +177,47 @@ def colorize_depth(depth_map, mask=None):
         valid_depths = depth_normalized[valid_mask]
         p5 = np.percentile(valid_depths, 5)
         p95 = np.percentile(valid_depths, 95)
-        depth_normalized[valid_mask] = (depth_normalized[valid_mask] - p5) / (max(p95 - p5, 1e-5))
-    
+        depth_normalized[valid_mask] = (depth_normalized[valid_mask] - p5) / (
+            p95 - p5 + 1e-8
+        )
+
+    import matplotlib.pyplot as plt
+
     colormap = plt.cm.turbo_r
     colored = colormap(depth_normalized)
     colored = (colored[:, :, :3] * 255).astype(np.uint8)
     colored[~valid_mask] = [255, 255, 255]
     return colored
 
+
 def colorize_normal(normal_map, mask=None):
-    if normal_map is None: return None
+    """Map normals from [-1,1] → [0,255] uint8; masked areas become grey."""
+    if normal_map is None:
+        return None
+
     normal_vis = normal_map.copy()
     if mask is not None:
-        invalid_mask = ~mask
-        normal_vis[invalid_mask] = [0, 0, 0]
+        normal_vis[~mask] = [0, 0, 0]
+
     normal_vis = (normal_vis + 1.0) / 2.0
     normal_vis = (normal_vis * 255).astype(np.uint8)
     return normal_vis
 
-def process_predictions_for_visualization(predictions, views, high_level_config, filter_black_bg=False, filter_white_bg=False):
+
+def process_predictions_for_visualization(
+    predictions, views, config, filter_black_bg=False, filter_white_bg=False
+):
+    """Build per-view dicts with image / depth / normal / mask / points3d."""
     processed_data = {}
+
     for view_idx, view in enumerate(views):
-        image = rgb(view["img"], norm_type=high_level_config["data_norm_type"])
+        image = rgb(view["img"], norm_type=config["data_norm_type"])
         pred_pts3d = predictions["world_points"][view_idx]
 
         view_data = {
             "image": image[0],
             "points3d": pred_pts3d,
-            "depth": predictions["depth"][view_idx].squeeze(),
+            "depth": None,
             "normal": None,
             "mask": None,
         }
@@ -211,136 +225,240 @@ def process_predictions_for_visualization(predictions, views, high_level_config,
         mask = predictions["final_mask"][view_idx].copy()
 
         if filter_black_bg:
-            view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
-            black_bg_mask = view_colors.sum(axis=2) >= 16
-            mask = mask & black_bg_mask
+            vc = image[0] * 255 if image[0].max() <= 1.0 else image[0]
+            mask = mask & (vc.sum(axis=2) >= 16)
 
         if filter_white_bg:
-            view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
-            white_bg_mask = ~((view_colors[:, :, 0] > 240) & (view_colors[:, :, 1] > 240) & (view_colors[:, :, 2] > 240))
-            mask = mask & white_bg_mask
+            vc = image[0] * 255 if image[0].max() <= 1.0 else image[0]
+            mask = mask & ~(
+                (vc[:, :, 0] > 240) & (vc[:, :, 1] > 240) & (vc[:, :, 2] > 240)
+            )
 
         view_data["mask"] = mask
-        normals, _ = points_to_normals(pred_pts3d, mask=view_data["mask"])
+        view_data["depth"] = predictions["depth"][view_idx].squeeze()
+
+        normals, _ = points_to_normals(pred_pts3d, mask=mask)
         view_data["normal"] = normals
+
         processed_data[view_idx] = view_data
-        
+
     return processed_data
 
-def update_view_selectors(processed_data):
-    if processed_data is None or len(processed_data) == 0:
-        choices = ["View 1"]
-    else:
-        choices = [f"View {i + 1}" for i in range(len(processed_data))]
-    return (
-        gr.Dropdown(choices=choices, value=choices[0]), 
-        gr.Dropdown(choices=choices, value=choices[0]), 
-        gr.Dropdown(choices=choices, value=choices[0]),
-    )
+
+# ── per-view accessors ────────────────────────────────────────────────────
+
+
+def _view_index_from_selector(selector_value):
+    try:
+        return int(selector_value.split()[1]) - 1
+    except Exception:
+        return 0
+
 
 def get_view_data_by_index(processed_data, view_index):
-    if processed_data is None or len(processed_data) == 0: return None
-    view_keys = list(processed_data.keys())
-    if view_index < 0 or view_index >= len(view_keys): view_index = 0
-    return processed_data[view_keys[view_index]]
+    if processed_data is None or len(processed_data) == 0:
+        return None
+    keys = list(processed_data.keys())
+    view_index = max(0, min(view_index, len(keys) - 1))
+    return processed_data[keys[view_index]]
+
 
 def update_depth_view(processed_data, view_index):
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None or view_data["depth"] is None: return None
-    return colorize_depth(view_data["depth"], mask=view_data.get("mask"))
+    vd = get_view_data_by_index(processed_data, view_index)
+    if vd is None or vd["depth"] is None:
+        return None
+    return colorize_depth(vd["depth"], mask=vd.get("mask"))
+
 
 def update_normal_view(processed_data, view_index):
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None or view_data["normal"] is None: return None
-    return colorize_normal(view_data["normal"], mask=view_data.get("mask"))
+    vd = get_view_data_by_index(processed_data, view_index)
+    if vd is None or vd["normal"] is None:
+        return None
+    return colorize_normal(vd["normal"], mask=vd.get("mask"))
+
 
 def update_measure_view(processed_data, view_index):
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None: return None, []
-    image = view_data["image"].copy()
+    """Return (image_with_mask_overlay, empty_points_list)."""
+    vd = get_view_data_by_index(processed_data, view_index)
+    if vd is None:
+        return None, []
+
+    image = vd["image"].copy()
     if image.dtype != np.uint8:
-        image = (image * 255).astype(np.uint8) if image.max() <= 1.0 else image.astype(np.uint8)
+        image = (
+            (image * 255).astype(np.uint8)
+            if image.max() <= 1.0
+            else image.astype(np.uint8)
+        )
 
-    if view_data["mask"] is not None:
-        invalid_mask = ~view_data["mask"]
-        if invalid_mask.any():
-            overlay_color = np.array([255, 220, 220], dtype=np.uint8)
+    if vd["mask"] is not None:
+        inv = ~vd["mask"]
+        if inv.any():
+            overlay = np.array([255, 220, 220], dtype=np.uint8)
             alpha = 0.5
             for c in range(3):
-                image[:, :, c] = np.where(invalid_mask, (1 - alpha) * image[:, :, c] + alpha * overlay_color[c], image[:, :, c]).astype(np.uint8)
+                image[:, :, c] = np.where(
+                    inv,
+                    (1 - alpha) * image[:, :, c] + alpha * overlay[c],
+                    image[:, :, c],
+                ).astype(np.uint8)
+
     return image, []
 
-def navigate_view(processed_data, current_selector_value, direction, update_fn):
-    if processed_data is None or len(processed_data) == 0: return "View 1", None
-    try: current_view = int(current_selector_value.split()[1]) - 1
-    except: current_view = 0
-    new_view = (current_view + direction) % len(processed_data)
-    new_selector_value = f"View {new_view + 1}"
-    return new_selector_value, update_fn(processed_data, new_view)
 
-def navigate_depth_view(p_data, s_val, dir): return navigate_view(p_data, s_val, dir, update_depth_view)
-def navigate_normal_view(p_data, s_val, dir): return navigate_view(p_data, s_val, dir, update_normal_view)
-def navigate_measure_view(p_data, s_val, dir):
-    res_sel, res_img = navigate_view(p_data, s_val, dir, lambda p, v: update_measure_view(p, v)[0])
-    return res_sel, res_img, []
+# ── view‑selector helpers ─────────────────────────────────────────────────
+
+
+def update_view_selectors(processed_data):
+    n = len(processed_data) if processed_data else 1
+    choices = [f"View {i + 1}" for i in range(n)]
+    return (
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
+    )
+
 
 def populate_visualization_tabs(processed_data):
     if processed_data is None or len(processed_data) == 0:
         return None, None, None, []
-    depth_vis = update_depth_view(processed_data, 0)
-    normal_vis = update_normal_view(processed_data, 0)
-    measure_img, _ = update_measure_view(processed_data, 0)
-    return depth_vis, normal_vis, measure_img, []
+    return (
+        update_depth_view(processed_data, 0),
+        update_normal_view(processed_data, 0),
+        update_measure_view(processed_data, 0)[0],
+        [],
+    )
 
-def measure(processed_data, measure_points, current_view_selector, event: gr.SelectData):
-    if processed_data is None or len(processed_data) == 0: return None, [], "No data available"
-    try: current_view_index = int(current_view_selector.split()[1]) - 1
-    except: current_view_index = 0
 
-    if current_view_index < 0 or current_view_index >= len(processed_data): current_view_index = 0
-    current_view = processed_data[list(processed_data.keys())[current_view_index]]
-    point2d = event.index[0], event.index[1]
+# ── navigation (prev / next) ─────────────────────────────────────────────
 
-    if current_view["mask"] is not None and 0 <= point2d[1] < current_view["mask"].shape[0] and 0 <= point2d[0] < current_view["mask"].shape[1]:
-        if not current_view["mask"][point2d[1], point2d[0]]:
-            masked_image, _ = update_measure_view(processed_data, current_view_index)
-            return masked_image, measure_points, '<span style="color: red; font-weight: bold;">Cannot measure on masked areas (shown in grey)</span>'
 
-    measure_points.append(point2d)
-    image, _ = update_measure_view(processed_data, current_view_index)
-    image = image.copy()
-    points3d = current_view["points3d"]
+def navigate_depth_view(processed_data, cur, direction):
+    if not processed_data:
+        return "View 1", None
+    idx = (_view_index_from_selector(cur) + direction) % len(processed_data)
+    return f"View {idx + 1}", update_depth_view(processed_data, idx)
 
-    if image.dtype != np.uint8:
-        image = (image * 255).astype(np.uint8) if image.max() <= 1.0 else image.astype(np.uint8)
 
-    for p in measure_points:
-        if 0 <= p[0] < image.shape[1] and 0 <= p[1] < image.shape[0]:
-            cv2.circle(image, p, radius=5, color=(255, 0, 0), thickness=2)
+def navigate_normal_view(processed_data, cur, direction):
+    if not processed_data:
+        return "View 1", None
+    idx = (_view_index_from_selector(cur) + direction) % len(processed_data)
+    return f"View {idx + 1}", update_normal_view(processed_data, idx)
+
+
+def navigate_measure_view(processed_data, cur, direction):
+    if not processed_data:
+        return "View 1", None, []
+    idx = (_view_index_from_selector(cur) + direction) % len(processed_data)
+    img, pts = update_measure_view(processed_data, idx)
+    return f"View {idx + 1}", img, pts
+
+
+# ── measure click handler ────────────────────────────────────────────────
+
 
-    depth_text = ""
-    for i, p in enumerate(measure_points):
-        if current_view["depth"] is not None and 0 <= p[1] < current_view["depth"].shape[0] and 0 <= p[0] < current_view["depth"].shape[1]:
-            depth_text += f"- **P{i + 1} depth: {current_view['depth'][p[1], p[0]]:.2f}m.**\n"
+def measure(processed_data, measure_points, current_view_selector, event: gr.SelectData):
+    """Two-click measurement: first click → depth, second click → depth + distance."""
+    try:
+        if processed_data is None or len(processed_data) == 0:
+            return None, [], "No data available"
+
+        vi = _view_index_from_selector(current_view_selector)
+        vi = max(0, min(vi, len(processed_data) - 1))
+        keys = list(processed_data.keys())
+        cv = processed_data[keys[vi]]
+        if cv is None:
+            return None, [], "No view data"
+
+        px, py = event.index[0], event.index[1]
+
+        # reject clicks on masked areas
+        if cv["mask"] is not None:
+            if 0 <= py < cv["mask"].shape[0] and 0 <= px < cv["mask"].shape[1]:
+                if not cv["mask"][py, px]:
+                    img, _ = update_measure_view(processed_data, vi)
+                    return (
+                        img,
+                        measure_points,
+                        '<span style="color:red;font-weight:bold;">'
+                        "Cannot measure on masked areas (grey overlay)</span>",
+                    )
+
+        measure_points.append((px, py))
+
+        img, _ = update_measure_view(processed_data, vi)
+        if img is None:
+            return None, [], "No image"
+        img = img.copy()
+        pts3d = cv["points3d"]
+
+        if img.dtype != np.uint8:
+            img = (
+                (img * 255).astype(np.uint8)
+                if img.max() <= 1.0
+                else img.astype(np.uint8)
+            )
 
-    if len(measure_points) == 2:
-        point1, point2 = measure_points
-        if 0 <= point1[0] < image.shape[1] and 0 <= point1[1] < image.shape[0] and 0 <= point2[0] < image.shape[1] and 0 <= point2[1] < image.shape[0]:
-            cv2.line(image, point1, point2, color=(255, 0, 0), thickness=2)
+        for p in measure_points:
+            if 0 <= p[0] < img.shape[1] and 0 <= p[1] < img.shape[0]:
+                cv2.circle(img, p, radius=5, color=(255, 0, 0), thickness=2)
+
+        depth_text = ""
+        for i, p in enumerate(measure_points):
+            if (
+                cv["depth"] is not None
+                and 0 <= p[1] < cv["depth"].shape[0]
+                and 0 <= p[0] < cv["depth"].shape[1]
+            ):
+                d = cv["depth"][p[1], p[0]]
+                depth_text += f"- **P{i+1} depth: {d:.2f}m.**\n"
+            elif (
+                pts3d is not None
+                and 0 <= p[1] < pts3d.shape[0]
+                and 0 <= p[0] < pts3d.shape[1]
+            ):
+                z = pts3d[p[1], p[0], 2]
+                depth_text += f"- **P{i+1} Z-coord: {z:.2f}m.**\n"
+
+        if len(measure_points) == 2:
+            p1, p2 = measure_points
+            if (
+                0 <= p1[0] < img.shape[1]
+                and 0 <= p1[1] < img.shape[0]
+                and 0 <= p2[0] < img.shape[1]
+                and 0 <= p2[1] < img.shape[0]
+            ):
+                cv2.line(img, p1, p2, color=(255, 0, 0), thickness=2)
+
+            dist_text = "- **Distance: Unable to compute**"
+            if (
+                pts3d is not None
+                and 0 <= p1[1] < pts3d.shape[0]
+                and 0 <= p1[0] < pts3d.shape[1]
+                and 0 <= p2[1] < pts3d.shape[0]
+                and 0 <= p2[0] < pts3d.shape[1]
+            ):
+                d3 = np.linalg.norm(pts3d[p1[1], p1[0]] - pts3d[p2[1], p2[0]])
+                dist_text = f"- **Distance: {d3:.2f}m**"
+
+            measure_points = []
+            return img, measure_points, depth_text + dist_text
+        else:
+            return img, measure_points, depth_text
 
-        distance_text = "- **Distance: Unable to compute**"
-        if points3d is not None and 0 <= point1[1] < points3d.shape[0] and 0 <= point1[0] < points3d.shape[1] and 0 <= point2[1] < points3d.shape[0] and 0 <= point2[0] < points3d.shape[1]:
-            distance = np.linalg.norm(points3d[point1[1], point1[0]] - points3d[point2[1], point2[0]])
-            distance_text = f"- **Distance: {distance:.2f}m**"
-        
-        return image, [], depth_text + distance_text
-    return image, measure_points, depth_text
+    except Exception as e:
+        print(f"Measure error: {e}")
+        return None, [], f"Error: {e}"
 
 
 # ============================================================================
-# Core Handling Functions (Uploads, Generation)
+# File Handling (images only — kept as original)
 # ============================================================================
+
+
 def handle_uploads(input_images):
+    """Copy uploaded images into a timestamped target_dir/images folder."""
     start_time = time.time()
     gc.collect()
     torch.cuda.empty_cache()
@@ -349,41 +467,71 @@ def handle_uploads(input_images):
     target_dir = f"input_images_{timestamp}"
     target_dir_images = os.path.join(target_dir, "images")
 
-    if os.path.exists(target_dir): shutil.rmtree(target_dir)
+    if os.path.exists(target_dir):
+        shutil.rmtree(target_dir)
     os.makedirs(target_dir)
     os.makedirs(target_dir_images)
 
     image_paths = []
+
     if input_images is not None:
         for file_data in input_images:
-            file_path = file_data["name"] if isinstance(file_data, dict) and "name" in file_data else str(file_data)
-            file_ext = os.path.splitext(file_path)[1].lower()
-            
-            if file_ext in [".heic", ".heif"]:
+            file_path = (
+                file_data["name"]
+                if isinstance(file_data, dict) and "name" in file_data
+                else str(file_data)
+            )
+
+            ext = os.path.splitext(file_path)[1].lower()
+            if ext in [".heic", ".heif"]:
                 try:
-                    with Image.open(file_path) as img:
-                        if img.mode not in ("RGB", "L"): img = img.convert("RGB")
-                        base_name = os.path.splitext(os.path.basename(file_path))[0]
-                        dst_path = os.path.join(target_dir_images, f"{base_name}.jpg")
-                        img.save(dst_path, "JPEG", quality=95)
-                        image_paths.append(dst_path)
+                    with Image.open(file_path) as im:
+                        if im.mode not in ("RGB", "L"):
+                            im = im.convert("RGB")
+                        base = os.path.splitext(os.path.basename(file_path))[0]
+                        dst = os.path.join(target_dir_images, f"{base}.jpg")
+                        im.save(dst, "JPEG", quality=95)
+                        image_paths.append(dst)
                 except Exception as e:
-                    dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
-                    shutil.copy(file_path, dst_path)
-                    image_paths.append(dst_path)
+                    print(f"HEIC convert error: {e}")
+                    dst = os.path.join(
+                        target_dir_images, os.path.basename(file_path)
+                    )
+                    shutil.copy(file_path, dst)
+                    image_paths.append(dst)
             else:
-                dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
-                shutil.copy(file_path, dst_path)
-                image_paths.append(dst_path)
+                dst = os.path.join(
+                    target_dir_images, os.path.basename(file_path)
+                )
+                shutil.copy(file_path, dst)
+                image_paths.append(dst)
 
     image_paths = sorted(image_paths)
-    print(f"Files copied to {target_dir_images}; took {time.time() - start_time:.3f} seconds")
+    print(
+        f"Files copied to {target_dir_images}; "
+        f"took {time.time() - start_time:.3f}s"
+    )
     return target_dir, image_paths
 
+
 def update_gallery_on_upload(input_images):
-    if not input_images: return None, None, None, None
+    """Handle new uploads — clear viewers, update gallery."""
+    if not input_images:
+        return None, None, None, None, None
     target_dir, image_paths = handle_uploads(input_images)
-    return None, target_dir, image_paths, "Upload complete. Click 'Start Reconstruction' to begin."
+    return (
+        None,  # clear Raw 3D
+        None,  # clear 3D View
+        target_dir,
+        image_paths,
+        "Upload complete. Click 'Start Reconstruction' to begin 3D processing.",
+    )
+
+
+# ============================================================================
+# Main Reconstruction
+# ============================================================================
+
 
 @spaces.GPU(duration=120)
 def gradio_demo(
@@ -396,33 +544,45 @@ def gradio_demo(
     apply_mask=True,
     show_mesh=True,
 ):
+    """Run reconstruction → produce GLBs + depth / normal / measure data."""
     if not os.path.isdir(target_dir) or target_dir == "None":
-        return [None]*2 + ["Please upload files first"] + [None]*9
+        return (
+            None, None,
+            "Please upload files first.",
+            None, None, None, None, None, "", None, None, None,
+        )
 
     start_time = time.time()
     gc.collect()
     torch.cuda.empty_cache()
 
     target_dir_images = os.path.join(target_dir, "images")
-    all_files = sorted(os.listdir(target_dir_images)) if os.path.isdir(target_dir_images) else []
-    frame_filter_choices = ["All"] + [f"{i}: {filename}" for i, filename in enumerate(all_files)]
+    all_files = (
+        sorted(os.listdir(target_dir_images))
+        if os.path.isdir(target_dir_images)
+        else []
+    )
+    all_files_display = [f"{i}: {f}" for i, f in enumerate(all_files)]
+    frame_filter_choices = ["All"] + all_files_display
 
+    # ── run model (Raw 3D logic — unchanged) ──────────────────────────────
     print("Running MapAnything model...")
     with torch.no_grad():
-        predictions, processed_data = run_model(
-            target_dir, apply_mask, filter_black_bg, filter_white_bg
-        )
+        predictions = run_model(target_dir, apply_mask)
 
     prediction_save_path = os.path.join(target_dir, "predictions.npz")
     np.savez(prediction_save_path, **predictions)
 
-    if frame_filter is None: frame_filter = "All"
+    if frame_filter is None:
+        frame_filter = "All"
 
-    glbfile = os.path.join(
+    # ── GLB for Raw 3D tab (unchanged) ────────────────────────────────────
+    raw_glb_path = os.path.join(
         target_dir,
-        f"glbscene_{frame_filter.replace('.', '').replace(':', '').replace(' ', '')}_cam{show_cam}_mesh{show_mesh}_black{filter_black_bg}_white{filter_white_bg}.glb",
+        "raw_"
+        + f"glbscene_{frame_filter.replace('.','').replace(':','').replace(' ','')}"
+        + f"_cam{show_cam}_mesh{show_mesh}.glb",
     )
-
     glbscene = predictions_to_glb(
         predictions,
         filter_by_frames=frame_filter,
@@ -432,298 +592,632 @@ def gradio_demo(
         as_mesh=show_mesh,
         conf_percentile=conf_thres,
     )
-    glbscene.export(file_obj=glbfile)
+    glbscene.export(file_obj=raw_glb_path)
+
+    # ── GLB for 3D View tab (same scene, separate file) ──────────────────
+    view_glb_path = os.path.join(
+        target_dir,
+        "view_"
+        + f"glbscene_{frame_filter.replace('.','').replace(':','').replace(' ','')}"
+        + f"_cam{show_cam}_mesh{show_mesh}.glb",
+    )
+    glbscene.export(file_obj=view_glb_path)
+
+    # ── process for Depth / Normal / Measure tabs ─────────────────────────
+    views = load_images(os.path.join(target_dir, "images"))
+    processed_data = process_predictions_for_visualization(
+        predictions, views, high_level_config, filter_black_bg, filter_white_bg
+    )
+    depth_vis, normal_vis, measure_img, _ = populate_visualization_tabs(
+        processed_data
+    )
+    depth_sel, normal_sel, measure_sel = update_view_selectors(processed_data)
 
     del predictions
     gc.collect()
     torch.cuda.empty_cache()
 
-    print(f"Total time elapsed: {time.time() - start_time:.2f} seconds")
-    log_msg = f"✅ Reconstruction successful ({len(all_files)} frames)"
-
-    depth_vis, normal_vis, measure_img, _ = populate_visualization_tabs(processed_data)
-    depth_selector, normal_selector, measure_selector = update_view_selectors(processed_data)
+    elapsed = time.time() - start_time
+    print(f"Total time elapsed: {elapsed:.2f}s")
+    log_msg = f"✅ Reconstruction successful ({len(all_files)} frames, {elapsed:.1f}s)"
 
     return (
-        glbfile, # Raw 3D Output
-        glbfile, # 3D View Output
+        raw_glb_path,
+        view_glb_path,
         log_msg,
-        gr.Dropdown(choices=frame_filter_choices, value=frame_filter, interactive=True),
+        gr.Dropdown(
+            choices=frame_filter_choices,
+            value=frame_filter,
+            interactive=True,
+        ),
         processed_data,
         depth_vis,
         normal_vis,
         measure_img,
-        "", 
-        depth_selector,
-        normal_selector,
-        measure_selector,
+        "",
+        depth_sel,
+        normal_sel,
+        measure_sel,
     )
 
-def clear_fields(): return None, None
-def update_log(): return "Loading and reconstructing..."
+
+# ============================================================================
+# UI Helpers
+# ============================================================================
+
+
+def clear_fields():
+    """Clear both 3D viewers."""
+    return None, None
+
+
+def update_log():
+    return "⏳ Loading and reconstructing…"
+
 
 def update_visualization(
-    target_dir, frame_filter, show_cam, is_example, conf_thres=None,
-    filter_black_bg=False, filter_white_bg=False, show_mesh=True,
+    target_dir,
+    frame_filter,
+    show_cam,
+    is_example,
+    conf_thres=None,
+    filter_black_bg=False,
+    filter_white_bg=False,
+    show_mesh=True,
 ):
-    if is_example == "True" or not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
-        return gr.update(), gr.update(), "No reconstruction available. Please reconstruct first."
+    """Re-render the GLB from saved predictions (live parameter tweaks)."""
+    if is_example == "True":
+        return gr.update(), gr.update(), "No reconstruction available."
 
-    predictions_path = os.path.join(target_dir, "predictions.npz")
-    if not os.path.exists(predictions_path):
-        return gr.update(), gr.update(), "No reconstruction available. Please run 'Start Reconstruction' first."
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return gr.update(), gr.update(), "No reconstruction available."
+
+    ppath = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(ppath):
+        return (
+            gr.update(),
+            gr.update(),
+            "Run 'Start Reconstruction' first.",
+        )
 
-    loaded = np.load(predictions_path, allow_pickle=True)
-    predictions = {key: loaded[key] for key in loaded.keys()}
+    loaded = np.load(ppath, allow_pickle=True)
+    predictions = {k: loaded[k] for k in loaded}
 
-    glbfile = os.path.join(
-        target_dir,
-        f"glbscene_{frame_filter.replace('.', '').replace(':', '').replace(' ', '')}_cam{show_cam}_mesh{show_mesh}_black{filter_black_bg}_white{filter_white_bg}.glb",
+    tag = (
+        f"{frame_filter.replace('.','').replace(':','').replace(' ','')}"
+        f"_cam{show_cam}_mesh{show_mesh}"
+        f"_black{filter_black_bg}_white{filter_white_bg}"
     )
 
-    if not os.path.exists(glbfile):
-        glbscene = predictions_to_glb(
-            predictions, filter_by_frames=frame_filter, show_cam=show_cam,
-            mask_black_bg=filter_black_bg, mask_white_bg=filter_white_bg,
-            as_mesh=show_mesh, conf_percentile=conf_thres,
-        )
-        glbscene.export(file_obj=glbfile)
+    raw_glb = os.path.join(target_dir, f"raw_glbscene_{tag}.glb")
+    view_glb = os.path.join(target_dir, f"view_glbscene_{tag}.glb")
+
+    glbscene = predictions_to_glb(
+        predictions,
+        filter_by_frames=frame_filter,
+        show_cam=show_cam,
+        mask_black_bg=filter_black_bg,
+        mask_white_bg=filter_white_bg,
+        as_mesh=show_mesh,
+        conf_percentile=conf_thres,
+    )
+    glbscene.export(file_obj=raw_glb)
+    glbscene.export(file_obj=view_glb)
+
+    return raw_glb, view_glb, "Visualization updated."
 
-    return glbfile, glbfile, "Visualization updated."
 
 def update_all_views_on_filter_change(
-    target_dir, filter_black_bg, filter_white_bg, processed_data,
-    depth_view_selector, normal_view_selector, measure_view_selector,
+    target_dir,
+    filter_black_bg,
+    filter_white_bg,
+    processed_data,
+    depth_sel,
+    normal_sel,
+    measure_sel,
 ):
+    """Regenerate per-view data when background-filter checkboxes change."""
     if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
         return processed_data, None, None, None, []
 
-    predictions_path = os.path.join(target_dir, "predictions.npz")
-    if not os.path.exists(predictions_path):
+    ppath = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(ppath):
         return processed_data, None, None, None, []
 
     try:
-        loaded = np.load(predictions_path, allow_pickle=True)
-        predictions = {key: loaded[key] for key in loaded.keys()}
-        image_folder_path = os.path.join(target_dir, "images")
-        views = load_images(image_folder_path)
+        loaded = np.load(ppath, allow_pickle=True)
+        predictions = {k: loaded[k] for k in loaded}
+        views = load_images(os.path.join(target_dir, "images"))
 
-        new_processed_data = process_predictions_for_visualization(
+        new_pd = process_predictions_for_visualization(
             predictions, views, high_level_config, filter_black_bg, filter_white_bg
         )
 
-        try: depth_view_idx = int(depth_view_selector.split()[1]) - 1 if depth_view_selector else 0
-        except: depth_view_idx = 0
-        try: normal_view_idx = int(normal_view_selector.split()[1]) - 1 if normal_view_selector else 0
-        except: normal_view_idx = 0
-        try: measure_view_idx = int(measure_view_selector.split()[1]) - 1 if measure_view_selector else 0
-        except: measure_view_idx = 0
+        di = _view_index_from_selector(depth_sel) if depth_sel else 0
+        ni = _view_index_from_selector(normal_sel) if normal_sel else 0
+        mi = _view_index_from_selector(measure_sel) if measure_sel else 0
 
-        depth_vis = update_depth_view(new_processed_data, depth_view_idx)
-        normal_vis = update_normal_view(new_processed_data, normal_view_idx)
-        measure_img, _ = update_measure_view(new_processed_data, measure_view_idx)
-
-        return new_processed_data, depth_vis, normal_vis, measure_img, []
+        return (
+            new_pd,
+            update_depth_view(new_pd, di),
+            update_normal_view(new_pd, ni),
+            update_measure_view(new_pd, mi)[0],
+            [],
+        )
     except Exception as e:
-        print(f"Error updating views on filter change: {e}")
+        print(f"Filter-change error: {e}")
         return processed_data, None, None, None, []
 
+
 # ============================================================================
-# Example Scenes Handlers
+# Example Scenes
 # ============================================================================
+
+
 def get_scene_info(examples_dir):
     import glob
+
     scenes = []
-    if not os.path.exists(examples_dir): return scenes
-    for scene_folder in sorted(os.listdir(examples_dir)):
-        scene_path = os.path.join(examples_dir, scene_folder)
-        if os.path.isdir(scene_path):
-            image_files = []
-            for ext in [".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif"]:
-                image_files.extend(glob.glob(os.path.join(scene_path, ext)))
-                image_files.extend(glob.glob(os.path.join(scene_path, ext.upper())))
-            if image_files:
-                image_files = sorted(image_files)
-                scenes.append({
-                    "name": scene_folder, "path": scene_path, "thumbnail": image_files[0],
-                    "num_images": len(image_files), "image_files": image_files,
-                })
+    if not os.path.exists(examples_dir):
+        return scenes
+
+    for folder in sorted(os.listdir(examples_dir)):
+        spath = os.path.join(examples_dir, folder)
+        if not os.path.isdir(spath):
+            continue
+        imgs = []
+        for ext in [".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif"]:
+            imgs.extend(glob.glob(os.path.join(spath, f"*{ext}")))
+            imgs.extend(glob.glob(os.path.join(spath, f"*{ext.upper()}")))
+        if imgs:
+            imgs = sorted(imgs)
+            scenes.append(
+                {
+                    "name": folder,
+                    "path": spath,
+                    "thumbnail": imgs[0],
+                    "num_images": len(imgs),
+                    "image_files": imgs,
+                }
+            )
     return scenes
 
+
 def load_example_scene(scene_name, examples_dir="examples"):
     scenes = get_scene_info(examples_dir)
-    selected_scene = next((s for s in scenes if s["name"] == scene_name), None)
-    if selected_scene is None: return None, None, None, "Scene not found"
+    sel = next((s for s in scenes if s["name"] == scene_name), None)
+    if sel is None:
+        return None, None, None, None, "Scene not found"
 
-    target_dir, image_paths = handle_uploads(selected_scene["image_files"])
+    target_dir, image_paths = handle_uploads(sel["image_files"])
     return (
-        None, None, target_dir, image_paths,
-        f"Loaded scene '{scene_name}' ({selected_scene['num_images']} images). Click 'Start Reconstruction' to begin.",
+        None,
+        None,
+        target_dir,
+        image_paths,
+        f"Loaded '{scene_name}' ({sel['num_images']} images). "
+        "Click 'Start Reconstruction' to begin.",
     )
 
+
 # ============================================================================
-# Gradio UI Layout
+# Gradio UI
 # ============================================================================
+
 theme = get_gradio_theme()
-APP_CSS = GRADIO_CSS + """
+
+APP_CSS = (
+    GRADIO_CSS
+    + """
 .gradio-container { max-width: 100% !important; }
 .gallery-container { max-height: 350px !important; overflow-y: auto !important; }
-.file-preview { max-height: 200px !important; overflow-y: auto !important; }
+.file-preview   { max-height: 200px !important; overflow-y: auto !important; }
 .textbox-container { max-height: 100px !important; }
 .tab-content { min-height: 550px !important; }
 """
+)
 
 with gr.Blocks(theme=theme, css=APP_CSS) as demo:
-    is_example = gr.Textbox(label="is_example", visible=False, value="None")
+
+    # ── hidden / state ────────────────────────────────────────────────────
+    is_example = gr.Textbox(visible=False, value="None")
+    target_dir_output = gr.Textbox(visible=False, value="None")
     processed_data_state = gr.State(value=None)
     measure_points_state = gr.State(value=[])
-    target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
 
     with gr.Row(equal_height=False):
-        # Left Side: Uploads & Options
+
+        # ── LEFT: upload ──────────────────────────────────────────────────
         with gr.Column(scale=1, min_width=300):
             gr.Markdown("### 📤 Input")
+
             input_images = gr.File(
-                file_count="multiple", label="Upload multiple images (3-10 recommended)", 
-                interactive=True, height=200, file_types=["image"]
+                file_count="multiple",
+                label="Upload images (3-10 recommended)",
+                interactive=True,
+                height=200,
             )
+
             image_gallery = gr.Gallery(
-                label="Image Preview", columns=3, height=350, object_fit="contain", preview=True
+                label="Image Preview",
+                columns=3,
+                height=350,
+                object_fit="contain",
+                preview=True,
             )
+
             with gr.Row():
-                submit_btn = gr.Button("🚀 Start Reconstruction", variant="primary", scale=2)
-                clear_btn = gr.ClearButton([input_images, target_dir_output, image_gallery], value="🗑️ Clear", scale=1)
-            
-            with gr.Accordion("⚙️ Advanced Options", open=False):
-                frame_filter = gr.Dropdown(choices=["All"], value="All", label="Display Frame")
-                conf_thres = gr.Slider(minimum=0, maximum=100, value=0, step=0.1, label="Confidence Threshold (Percentile)")
-                show_cam = gr.Checkbox(label="Show Camera", value=True)
-                show_mesh = gr.Checkbox(label="Show Mesh", value=True)
-                filter_black_bg = gr.Checkbox(label="Filter Black Background", value=False)
-                filter_white_bg = gr.Checkbox(label="Filter White Background", value=False)
-                apply_mask_checkbox = gr.Checkbox(label="Apply Depth Mask", value=True)
-                
-            with gr.Accordion("🖼️ Example Scenes", open=False):
-                scenes = get_scene_info("examples")
-                if scenes:
-                    for i in range(0, len(scenes), 4):
-                        with gr.Row(equal_height=True):
-                            for j in range(4):
-                                if (i + j) < len(scenes):
-                                    scene = scenes[i + j]
-                                    with gr.Column(scale=1, min_width=150):
-                                        scene_img = gr.Image(value=scene["thumbnail"], height=150, interactive=False, show_label=False)
-                                        gr.Markdown(f"{scene['name']} ({scene['num_images']} images)", elem_classes=["text-center"])
-                                        scene_img.select(
-                                            fn=lambda n=scene["name"]: load_example_scene(n),
-                                            outputs=[gr.Model3D(), gr.Model3D(), target_dir_output, image_gallery, gr.Textbox()]
-                                        )
-
-        # Right Side: Visualization Tabs
+                submit_btn = gr.Button(
+                    "🚀 Start Reconstruction", variant="primary", scale=2
+                )
+                clear_btn = gr.ClearButton(
+                    [input_images, target_dir_output, image_gallery],
+                    value="🗑️ Clear",
+                    scale=1,
+                )
+
+        # ── RIGHT: output tabs ────────────────────────────────────────────
         with gr.Column(scale=2, min_width=600):
             gr.Markdown("### 🎯 Output")
-            log_output = gr.Textbox(
-                value="📌 Please upload images, then click 'Start Reconstruction'", 
-                label="Status Information", interactive=False, lines=1, max_lines=1
-            )
-            
+
             with gr.Tabs():
+
+                # ---- Tab 1: Raw 3D (unchanged) ----
                 with gr.Tab("🏗️ Raw 3D"):
-                    raw_3d_output = gr.Model3D(height=550, zoom_speed=0.5, pan_speed=0.5, clear_color=[0.0, 0.0, 0.0, 0.0])
-                with gr.Tab("3D View"):
-                    view_3d_output = gr.Model3D(height=550, zoom_speed=0.5, pan_speed=0.5, clear_color=[0.0, 0.0, 0.0, 0.0])
-                
-                with gr.Tab("Depth"):
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_depth_btn = gr.Button("◀ Previous", size="sm", scale=1)
-                        depth_view_selector = gr.Dropdown(choices=["View 1"], value="View 1", label="Select View", scale=2, interactive=True)
-                        next_depth_btn = gr.Button("Next ▶", size="sm", scale=1)
-                    depth_map = gr.Image(type="numpy", label="Colorized Depth Map", format="png", interactive=False)
-                    
-                with gr.Tab("Normal"):
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_normal_btn = gr.Button("◀ Previous", size="sm", scale=1)
-                        normal_view_selector = gr.Dropdown(choices=["View 1"], value="View 1", label="Select View", scale=2, interactive=True)
-                        next_normal_btn = gr.Button("Next ▶", size="sm", scale=1)
-                    normal_map = gr.Image(type="numpy", label="Normal Map", format="png", interactive=False)
-                    
-                with gr.Tab("Measure"):
-                    gr.Markdown(MEASURE_INSTRUCTIONS_HTML)
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_measure_btn = gr.Button("◀ Previous", size="sm", scale=1)
-                        measure_view_selector = gr.Dropdown(choices=["View 1"], value="View 1", label="Select View", scale=2, interactive=True)
-                        next_measure_btn = gr.Button("Next ▶", size="sm", scale=1)
-                    measure_image = gr.Image(type="numpy", show_label=False, format="webp", interactive=False)
-                    gr.Markdown("**Note:** Light-grey areas indicate regions with no depth information where measurements cannot be taken.")
+                    raw_3d_output = gr.Model3D(
+                        height=550,
+                        zoom_speed=0.5,
+                        pan_speed=0.5,
+                        clear_color=[0.0, 0.0, 0.0, 0.0],
+                    )
+
+                # ---- Tab 2: 3D View (unchanged) ----
+                with gr.Tab("🔮 3D View"):
+                    view_3d_output = gr.Model3D(
+                        height=550,
+                        zoom_speed=0.5,
+                        pan_speed=0.5,
+                        clear_color=[0.0, 0.0, 0.0, 0.0],
+                    )
+
+                # ---- Tab 3: Depth ----
+                with gr.Tab("🌊 Depth"):
+                    with gr.Row():
+                        prev_depth_btn = gr.Button(
+                            "◀ Previous", size="sm", scale=1
+                        )
+                        depth_view_selector = gr.Dropdown(
+                            choices=["View 1"],
+                            value="View 1",
+                            label="Select View",
+                            scale=2,
+                            interactive=True,
+                            allow_custom_value=True,
+                        )
+                        next_depth_btn = gr.Button(
+                            "Next ▶", size="sm", scale=1
+                        )
+                    depth_map = gr.Image(
+                        type="numpy",
+                        label="Colorized Depth Map",
+                        format="png",
+                        interactive=False,
+                    )
+
+                # ---- Tab 4: Normal ----
+                with gr.Tab("🧭 Normal"):
+                    with gr.Row():
+                        prev_normal_btn = gr.Button(
+                            "◀ Previous", size="sm", scale=1
+                        )
+                        normal_view_selector = gr.Dropdown(
+                            choices=["View 1"],
+                            value="View 1",
+                            label="Select View",
+                            scale=2,
+                            interactive=True,
+                            allow_custom_value=True,
+                        )
+                        next_normal_btn = gr.Button(
+                            "Next ▶", size="sm", scale=1
+                        )
+                    normal_map = gr.Image(
+                        type="numpy",
+                        label="Normal Map",
+                        format="png",
+                        interactive=False,
+                    )
+
+                # ---- Tab 5: Measure ----
+                with gr.Tab("📏 Measure"):
+                    gr.Markdown(MEASURE_INSTRUCTIONS)
+                    with gr.Row():
+                        prev_measure_btn = gr.Button(
+                            "◀ Previous", size="sm", scale=1
+                        )
+                        measure_view_selector = gr.Dropdown(
+                            choices=["View 1"],
+                            value="View 1",
+                            label="Select View",
+                            scale=2,
+                            interactive=True,
+                            allow_custom_value=True,
+                        )
+                        next_measure_btn = gr.Button(
+                            "Next ▶", size="sm", scale=1
+                        )
+                    measure_image = gr.Image(
+                        type="numpy",
+                        show_label=False,
+                        format="webp",
+                        interactive=False,
+                        sources=[],
+                    )
+                    gr.Markdown(
+                        "**Note:** Light-grey areas have no valid depth — "
+                        "measurements cannot be taken there."
+                    )
                     measure_text = gr.Markdown("")
 
-    # ============================================================================
-    # Event Bindings
-    # ============================================================================
+            log_output = gr.Textbox(
+                value="📌 Upload images, then click 'Start Reconstruction'.",
+                label="Status",
+                interactive=False,
+                lines=1,
+                max_lines=1,
+            )
+
+    # ── Advanced Options ──────────────────────────────────────────────────
+    with gr.Accordion("⚙️ Advanced Options", open=False):
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=1, min_width=300):
+                gr.Markdown("#### Visualization Parameters")
+                frame_filter = gr.Dropdown(
+                    choices=["All"], value="All", label="Display Frame"
+                )
+                conf_thres = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=0,
+                    step=0.1,
+                    label="Confidence Threshold (Percentile)",
+                )
+                show_cam = gr.Checkbox(label="Show Camera", value=True)
+                show_mesh = gr.Checkbox(label="Show Mesh", value=True)
+                filter_black_bg = gr.Checkbox(
+                    label="Filter Black Background", value=False
+                )
+                filter_white_bg = gr.Checkbox(
+                    label="Filter White Background", value=False
+                )
+
+            with gr.Column(scale=1, min_width=300):
+                gr.Markdown("#### Reconstruction Parameters")
+                apply_mask_checkbox = gr.Checkbox(
+                    label="Apply Depth Mask", value=True
+                )
+
+    # ── Example Scenes ────────────────────────────────────────────────────
+    with gr.Accordion("🖼️ Example Scenes", open=False):
+        scenes = get_scene_info("examples")
+        if scenes:
+            for i in range(0, len(scenes), 4):
+                with gr.Row(equal_height=True):
+                    for j in range(4):
+                        si = i + j
+                        if si < len(scenes):
+                            sc = scenes[si]
+                            with gr.Column(scale=1, min_width=150):
+                                sc_img = gr.Image(
+                                    value=sc["thumbnail"],
+                                    height=150,
+                                    interactive=False,
+                                    show_label=False,
+                                    sources=[],
+                                    container=False,
+                                )
+                                gr.Markdown(
+                                    f"{sc['name']} ({sc['num_images']} imgs)",
+                                    elem_classes=["text-center"],
+                                )
+                                sc_img.select(
+                                    fn=lambda n=sc["name"]: load_example_scene(n),
+                                    outputs=[
+                                        raw_3d_output,
+                                        view_3d_output,
+                                        target_dir_output,
+                                        image_gallery,
+                                        log_output,
+                                    ],
+                                )
+
+    # ======================================================================
+    # EVENT BINDING
+    # ======================================================================
+
+    # ── upload → gallery ──────────────────────────────────────────────────
     input_images.change(
-        fn=update_gallery_on_upload, inputs=[input_images], 
-        outputs=[raw_3d_output, target_dir_output, image_gallery, log_output]
+        fn=update_gallery_on_upload,
+        inputs=[input_images],
+        outputs=[
+            raw_3d_output,
+            view_3d_output,
+            target_dir_output,
+            image_gallery,
+            log_output,
+        ],
     )
 
+    # ── reconstruct ───────────────────────────────────────────────────────
     submit_btn.click(
-        fn=clear_fields, outputs=[raw_3d_output, view_3d_output]
+        fn=clear_fields,
+        outputs=[raw_3d_output, view_3d_output],
     ).then(
-        fn=update_log, outputs=[log_output]
+        fn=update_log,
+        outputs=[log_output],
     ).then(
         fn=gradio_demo,
         inputs=[
-            target_dir_output, frame_filter, show_cam, filter_black_bg, filter_white_bg, 
-            conf_thres, apply_mask_checkbox, show_mesh
+            target_dir_output,
+            frame_filter,
+            show_cam,
+            filter_black_bg,
+            filter_white_bg,
+            conf_thres,
+            apply_mask_checkbox,
+            show_mesh,
         ],
         outputs=[
-            raw_3d_output, view_3d_output, log_output, frame_filter, processed_data_state,
-            depth_map, normal_map, measure_image, measure_text,
-            depth_view_selector, normal_view_selector, measure_view_selector
-        ]
+            raw_3d_output,
+            view_3d_output,
+            log_output,
+            frame_filter,
+            processed_data_state,
+            depth_map,
+            normal_map,
+            measure_image,
+            measure_text,
+            depth_view_selector,
+            normal_view_selector,
+            measure_view_selector,
+        ],
     ).then(
-        fn=lambda: "False", outputs=[is_example]
+        fn=lambda: "False",
+        outputs=[is_example],
     )
-    
+
+    # ── clear ─────────────────────────────────────────────────────────────
     clear_btn.add([raw_3d_output, view_3d_output, log_output])
 
-    # Re-visualization Updates
-    for component in [frame_filter, show_cam, conf_thres, show_mesh]:
-        component.change(
+    # ── live viz-parameter updates (3D viewers only) ──────────────────────
+    for comp in [frame_filter, show_cam, conf_thres, show_mesh]:
+        comp.change(
             fn=update_visualization,
-            inputs=[target_dir_output, frame_filter, show_cam, is_example, conf_thres, filter_black_bg, filter_white_bg, show_mesh],
-            outputs=[raw_3d_output, view_3d_output, log_output]
+            inputs=[
+                target_dir_output,
+                frame_filter,
+                show_cam,
+                is_example,
+                conf_thres,
+                filter_black_bg,
+                filter_white_bg,
+                show_mesh,
+            ],
+            outputs=[raw_3d_output, view_3d_output, log_output],
         )
 
-    # Filtering Updates (Updates both 3D components + Processed Data Tabs)
-    for filter_comp in [filter_black_bg, filter_white_bg]:
-        filter_comp.change(
+    # background-filter changes → update BOTH 3D views AND per-view tabs
+    for bg_comp in [filter_black_bg, filter_white_bg]:
+        bg_comp.change(
             fn=update_visualization,
-            inputs=[target_dir_output, frame_filter, show_cam, is_example, conf_thres, filter_black_bg, filter_white_bg, show_mesh],
-            outputs=[raw_3d_output, view_3d_output, log_output]
+            inputs=[
+                target_dir_output,
+                frame_filter,
+                show_cam,
+                is_example,
+                conf_thres,
+                filter_black_bg,
+                filter_white_bg,
+                show_mesh,
+            ],
+            outputs=[raw_3d_output, view_3d_output, log_output],
         ).then(
             fn=update_all_views_on_filter_change,
-            inputs=[target_dir_output, filter_black_bg, filter_white_bg, processed_data_state, depth_view_selector, normal_view_selector, measure_view_selector],
-            outputs=[processed_data_state, depth_map, normal_map, measure_image, measure_points_state]
+            inputs=[
+                target_dir_output,
+                filter_black_bg,
+                filter_white_bg,
+                processed_data_state,
+                depth_view_selector,
+                normal_view_selector,
+                measure_view_selector,
+            ],
+            outputs=[
+                processed_data_state,
+                depth_map,
+                normal_map,
+                measure_image,
+                measure_points_state,
+            ],
         )
 
-    # Measure Interactions
-    measure_image.select(
-        fn=measure, inputs=[processed_data_state, measure_points_state, measure_view_selector],
-        outputs=[measure_image, measure_points_state, measure_text]
+    # ── Depth navigation ─────────────────────────────────────────────────
+    prev_depth_btn.click(
+        fn=lambda pd, cs: navigate_depth_view(pd, cs, -1),
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_view_selector, depth_map],
+    )
+    next_depth_btn.click(
+        fn=lambda pd, cs: navigate_depth_view(pd, cs, 1),
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_view_selector, depth_map],
+    )
+    depth_view_selector.change(
+        fn=lambda pd, sv: (
+            update_depth_view(pd, _view_index_from_selector(sv))
+            if sv
+            else None
+        ),
+        inputs=[processed_data_state, depth_view_selector],
+        outputs=[depth_map],
     )
 
-    # View Navigation Bindings
-    prev_depth_btn.click(lambda p, c: navigate_depth_view(p, c, -1), inputs=[processed_data_state, depth_view_selector], outputs=[depth_view_selector, depth_map])
-    next_depth_btn.click(lambda p, c: navigate_depth_view(p, c, 1), inputs=[processed_data_state, depth_view_selector], outputs=[depth_view_selector, depth_map])
-    depth_view_selector.change(lambda p, s: update_depth_view(p, int(s.split()[1])-1) if s else None, inputs=[processed_data_state, depth_view_selector], outputs=[depth_map])
+    # ── Normal navigation ─────────────────────────────────────────────────
+    prev_normal_btn.click(
+        fn=lambda pd, cs: navigate_normal_view(pd, cs, -1),
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_view_selector, normal_map],
+    )
+    next_normal_btn.click(
+        fn=lambda pd, cs: navigate_normal_view(pd, cs, 1),
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_view_selector, normal_map],
+    )
+    normal_view_selector.change(
+        fn=lambda pd, sv: (
+            update_normal_view(pd, _view_index_from_selector(sv))
+            if sv
+            else None
+        ),
+        inputs=[processed_data_state, normal_view_selector],
+        outputs=[normal_map],
+    )
 
-    prev_normal_btn.click(lambda p, c: navigate_normal_view(p, c, -1), inputs=[processed_data_state, normal_view_selector], outputs=[normal_view_selector, normal_map])
-    next_normal_btn.click(lambda p, c: navigate_normal_view(p, c, 1), inputs=[processed_data_state, normal_view_selector], outputs=[normal_view_selector, normal_map])
-    normal_view_selector.change(lambda p, s: update_normal_view(p, int(s.split()[1])-1) if s else None, inputs=[processed_data_state, normal_view_selector], outputs=[normal_map])
+    # ── Measure navigation + click ────────────────────────────────────────
+    prev_measure_btn.click(
+        fn=lambda pd, cs: navigate_measure_view(pd, cs, -1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
+    )
+    next_measure_btn.click(
+        fn=lambda pd, cs: navigate_measure_view(pd, cs, 1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
+    )
+    measure_view_selector.change(
+        fn=lambda pd, sv: (
+            update_measure_view(pd, _view_index_from_selector(sv))
+            if sv
+            else (None, [])
+        ),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state],
+    )
+    measure_image.select(
+        fn=measure,
+        inputs=[
+            processed_data_state,
+            measure_points_state,
+            measure_view_selector,
+        ],
+        outputs=[measure_image, measure_points_state, measure_text],
+    )
 
-    prev_measure_btn.click(lambda p, c: navigate_measure_view(p, c, -1), inputs=[processed_data_state, measure_view_selector], outputs=[measure_view_selector, measure_image, measure_points_state])
-    next_measure_btn.click(lambda p, c: navigate_measure_view(p, c, 1), inputs=[processed_data_state, measure_view_selector], outputs=[measure_view_selector, measure_image, measure_points_state])
-    measure_view_selector.change(lambda p, s: update_measure_view(p, int(s.split()[1])-1) if s else (None, []), inputs=[processed_data_state, measure_view_selector], outputs=[measure_image, measure_points_state])
 
+# ============================================================================
+# Launch
+# ============================================================================
 
-demo.queue(max_size=20).launch(theme=theme, css=APP_CSS, show_error=True, share=True, ssr_mode=False)
+demo.queue(max_size=20).launch(
+    theme=theme, css=APP_CSS, show_error=True, share=True, ssr_mode=False
+)