Update app.py

app.py

@@ -9,55 +9,52 @@ os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
 
 import cv2
 import gradio as gr
-import matplotlib.pyplot as plt
 import numpy as np
 import spaces
 import torch
 from PIL import Image
 from pillow_heif import register_heif_opener
 
-from mapanything.utils.geometry import depthmap_to_world_frame
+register_heif_opener()
+sys.path.append("mapanything/")
+
+from mapanything.utils.geometry import depthmap_to_world_frame, points_to_normals
+from mapanything.utils.image import load_images, rgb
+
 from mapanything.utils.hf_utils.css_and_html import (
-    get_gradio_theme,
     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
 
-# Optional imports with fallbacks
+# Import Raw 3D GLB builder (from viz module — supports conf_percentile)
+from mapanything.utils.hf_utils.viz import predictions_to_glb as predictions_to_glb_raw
+
+# Import 3D View GLB builder (from visual_util module — separate implementation)
 try:
-    from mapanything.utils.geometry import points_to_normals
+    from mapanything.utils.hf_utils.visual_util import (
+        predictions_to_glb as predictions_to_glb_view,
+    )
 except ImportError:
-    def points_to_normals(points3d, mask=None):
-        """Fallback: compute surface normals from 3D point cloud via cross products"""
-        H, W, _ = points3d.shape
-        dpdx = np.zeros_like(points3d)
-        dpdy = np.zeros_like(points3d)
-        dpdx[:, :-1] = points3d[:, 1:] - points3d[:, :-1]
-        dpdy[:-1, :] = points3d[1:, :] - points3d[:-1, :]
-        normals = np.cross(dpdx, dpdy)
-        norms = np.linalg.norm(normals, axis=-1, keepdims=True)
-        norms = np.maximum(norms, 1e-8)
-        normals = normals / norms
-        valid = norms.squeeze(-1) > 1e-6
-        if mask is not None:
-            valid = valid & mask
-        return normals, valid
+    # Fallback: reuse the viz version if visual_util is unavailable
+    from mapanything.utils.hf_utils.viz import (
+        predictions_to_glb as predictions_to_glb_view,
+    )
 
+# Optional imports for Measure tab instructions & acknowledgements
 try:
     from mapanything.utils.hf_utils.css_and_html import MEASURE_INSTRUCTIONS_HTML
 except ImportError:
-    MEASURE_INSTRUCTIONS_HTML = """
-**📏 Measurement Tool:**
-1. Click on the **first point** in the image to mark it
-2. Click on the **second point** to measure the 3D distance between them
-3. The depth of each point and the computed 3D distance will be displayed below
-4. After each measurement, click two new points for a new measurement
-"""
+    MEASURE_INSTRUCTIONS_HTML = (
+        "**Instructions:** Click two points on the image to measure "
+        "the 3D distance between them. Points and distance are shown in metres."
+    )
 
-register_heif_opener()
-sys.path.append("mapanything/")
+try:
+    from mapanything.utils.hf_utils.css_and_html import get_acknowledgements_html
+except ImportError:
+    get_acknowledgements_html = None
+
+from mapanything.utils.hf_utils.hf_helpers import initialize_mapanything_model
 
 
 # ============================================================================
@@ -88,27 +85,30 @@ model = None
 
 
 # ============================================================================
-# Core Model Inference (KEPT AS-IS)
+# Core Model Inference
 # ============================================================================
 
+
 @spaces.GPU(duration=120)
 def run_model(
     target_dir,
     apply_mask=True,
+    filter_black_bg=False,
+    filter_white_bg=False,
 ):
     """
-    Run the MapAnything model
+    Run the MapAnything model on images in target_dir/images.
+    Returns (predictions dict, processed_data dict for per-view tabs).
     """
     global model
     import torch
 
     print(f"Processing images: {target_dir}")
 
-    # Device check
     device = "cuda" if torch.cuda.is_available() else "cpu"
     device = torch.device(device)
 
-    # Initialize MapAnything model - from HuggingFace
+    # Initialise model on first call
     if model is None:
         print("📥 Loading MapAnything from HuggingFace...")
         model = initialize_mapanything_model(high_level_config, device)
@@ -127,13 +127,16 @@ def run_model(
     if len(views) == 0:
         raise ValueError("No images found")
 
-    # Run MapAnything inference
+    # Run inference
     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,
     )
 
-    # Convert prediction results
+    # ── Build predictions dict ──────────────────────────────────────────
     predictions = {}
     extrinsic_list = []
     intrinsic_list = []
@@ -178,65 +181,25 @@ def run_model(
     if len(depth_maps.shape) == 3:
         depth_maps = depth_maps[..., np.newaxis]
     predictions["depth"] = depth_maps
-
     predictions["images"] = np.stack(images_list, axis=0)
     predictions["final_mask"] = np.stack(final_mask_list, axis=0)
 
-    # Cleanup
-    torch.cuda.empty_cache()
+    # ── Build processed_data for Depth / Normal / Measure tabs ──────────
+    processed_data = process_predictions_for_visualization(
+        predictions, views, high_level_config, filter_black_bg, filter_white_bg
+    )
 
-    return predictions
+    torch.cuda.empty_cache()
+    return predictions, processed_data
 
 
 # ============================================================================
-# Visualization Processing Functions (NEW - for Depth, Normal, Measure tabs)
+# Visualisation Helpers
 # ============================================================================
 
-def process_predictions_for_visualization(
-    predictions, filter_black_bg=False, filter_white_bg=False
-):
-    """Extract depth, normal, and 3D points from predictions for per-view visualization tabs."""
-    processed_data = {}
-    num_views = predictions["images"].shape[0]
-
-    for view_idx in range(num_views):
-        image = predictions["images"][view_idx]          # (H, W, 3)
-        pred_pts3d = predictions["world_points"][view_idx]  # (H, W, 3)
-        depth = predictions["depth"][view_idx].squeeze()    # (H, W)
-        mask = predictions["final_mask"][view_idx].copy()   # (H, W)
-
-        # Apply black background filtering
-        if filter_black_bg:
-            view_colors = image * 255 if image.max() <= 1.0 else image.copy()
-            black_bg_mask = view_colors.sum(axis=2) >= 16
-            mask = mask & black_bg_mask
-
-        # Apply white background filtering
-        if filter_white_bg:
-            view_colors = image * 255 if image.max() <= 1.0 else image.copy()
-            white_bg_mask = ~(
-                (view_colors[:, :, 0] > 240)
-                & (view_colors[:, :, 1] > 240)
-                & (view_colors[:, :, 2] > 240)
-            )
-            mask = mask & white_bg_mask
-
-        # Compute surface normals from 3D points
-        normals, _ = points_to_normals(pred_pts3d, mask=mask)
-
-        processed_data[view_idx] = {
-            "image": image,
-            "points3d": pred_pts3d,
-            "depth": depth,
-            "normal": normals,
-            "mask": mask,
-        }
-
-    return processed_data
-
 
 def colorize_depth(depth_map, mask=None):
-    """Convert depth map to colorized visualization using turbo_r colormap."""
+    """Depth map → turbo-coloured uint8 image."""
     if depth_map is None:
         return None
 
@@ -250,160 +213,183 @@ 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)
-        if p95 > p5:
-            depth_normalized[valid_mask] = (depth_normalized[valid_mask] - p5) / (p95 - p5)
-        else:
-            depth_normalized[valid_mask] = 0.5
+        if p95 - p5 > 0:
+            depth_normalized[valid_mask] = (
+                depth_normalized[valid_mask] - p5
+            ) / (p95 - p5)
+
+    import matplotlib.pyplot as plt
 
     colormap = plt.cm.turbo_r
-    colored = colormap(np.clip(depth_normalized, 0, 1))
+    colored = colormap(depth_normalized)
     colored = (colored[:, :, :3] * 255).astype(np.uint8)
-
-    # Set invalid pixels to white
     colored[~valid_mask] = [255, 255, 255]
-
     return colored
 
 
 def colorize_normal(normal_map, mask=None):
-    """Convert normal map to colorized visualization."""
+    """Normal map → RGB uint8 image."""
     if normal_map is None:
         return None
 
     normal_vis = normal_map.copy()
-
     if mask is not None:
         normal_vis[~mask] = [0, 0, 0]
 
-    # Map normals from [-1, 1] to [0, 1] then to [0, 255]
     normal_vis = (normal_vis + 1.0) / 2.0
-    normal_vis = np.clip(normal_vis, 0, 1)
     normal_vis = (normal_vis * 255).astype(np.uint8)
-
     return normal_vis
 
 
+def process_predictions_for_visualization(
+    predictions, views, config, filter_black_bg=False, filter_white_bg=False
+):
+    """Extract per-view depth, normal, 3-D points and mask."""
+    processed_data = {}
+
+    for view_idx, view in enumerate(views):
+        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": None,
+            "normal": None,
+            "mask": None,
+        }
+
+        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]
+            mask = mask & (view_colors.sum(axis=2) >= 16)
+
+        if filter_white_bg:
+            view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
+            mask = mask & ~(
+                (view_colors[:, :, 0] > 240)
+                & (view_colors[:, :, 1] > 240)
+                & (view_colors[:, :, 2] > 240)
+            )
+
+        view_data["mask"] = mask
+        view_data["depth"] = predictions["depth"][view_idx].squeeze()
+
+        normals, _ = points_to_normals(pred_pts3d, mask=view_data["mask"])
+        view_data["normal"] = normals
+
+        processed_data[view_idx] = view_data
+
+    return processed_data
+
+
+# ============================================================================
+# View Navigation & Update Functions
+# ============================================================================
+
+
 def update_view_selectors(processed_data):
-    """Update view selector dropdowns based on available views."""
+    """Return three Dropdown updates matching the number of views."""
     if processed_data is None or len(processed_data) == 0:
         choices = ["View 1"]
     else:
-        num_views = len(processed_data)
-        choices = [f"View {i + 1}" for i in range(num_views)]
-
+        choices = [f"View {i + 1}" for i in range(len(processed_data))]
     return (
-        gr.Dropdown(choices=choices, value=choices[0]),  # depth_view_selector
-        gr.Dropdown(choices=choices, value=choices[0]),  # normal_view_selector
-        gr.Dropdown(choices=choices, value=choices[0]),  # measure_view_selector
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
+        gr.Dropdown(choices=choices, value=choices[0]),
     )
 
 
-def get_view_data_by_index(processed_data, view_index):
-    """Get view data by index, handling bounds."""
+def _view_data(processed_data, view_index):
+    """Safe accessor."""
     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]]
+    keys = list(processed_data.keys())
+    idx = max(0, min(view_index, len(keys) - 1))
+    return processed_data[keys[idx]]
 
 
 def update_depth_view(processed_data, view_index):
-    """Update depth view for a specific view index."""
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None or view_data["depth"] is None:
+    vd = _view_data(processed_data, view_index)
+    if vd is None or vd["depth"] is None:
         return None
-    return colorize_depth(view_data["depth"], mask=view_data.get("mask"))
+    return colorize_depth(vd["depth"], mask=vd.get("mask"))
 
 
 def update_normal_view(processed_data, view_index):
-    """Update normal view for a specific view index."""
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None or view_data["normal"] is None:
+    vd = _view_data(processed_data, view_index)
+    if vd is None or vd["normal"] is None:
         return None
-    return colorize_normal(view_data["normal"], mask=view_data.get("mask"))
+    return colorize_normal(vd["normal"], mask=vd.get("mask"))
 
 
 def update_measure_view(processed_data, view_index):
-    """Update measure view for a specific view index with mask overlay."""
-    view_data = get_view_data_by_index(processed_data, view_index)
-    if view_data is None:
+    """Return (image_with_mask_overlay, empty_points_list)."""
+    vd = _view_data(processed_data, view_index)
+    if vd is None:
         return None, []
 
-    image = view_data["image"].copy()
-
-    # Ensure image is uint8
+    image = vd["image"].copy()
     if image.dtype != np.uint8:
-        if image.max() <= 1.0:
-            image = (image * 255).astype(np.uint8)
-        else:
-            image = image.astype(np.uint8)
+        image = (
+            (image * 255).astype(np.uint8)
+            if image.max() <= 1.0
+            else image.astype(np.uint8)
+        )
 
-    # Apply mask overlay — light pink tint on invalid regions
-    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:
+        invalid = ~vd["mask"]
+        if invalid.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],
+                    invalid,
+                    (1 - alpha) * image[:, :, c] + alpha * overlay[c],
                     image[:, :, c],
                 ).astype(np.uint8)
 
     return image, []
 
 
-def navigate_depth_view(processed_data, current_selector_value, direction):
-    """Navigate depth view (direction: -1 for previous, +1 for next)."""
-    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 Exception:
-        current_view = 0
-    num_views = len(processed_data)
-    new_view = (current_view + direction) % num_views
-    new_selector_value = f"View {new_view + 1}"
-    depth_vis = update_depth_view(processed_data, new_view)
-    return new_selector_value, depth_vis
+# ── Navigation helpers ─────────────────────────────────────────────────
 
 
-def navigate_normal_view(processed_data, current_selector_value, direction):
-    """Navigate normal view (direction: -1 for previous, +1 for next)."""
+def _navigate(processed_data, current_selector, direction, update_fn):
+    """Generic prev / next navigation."""
     if processed_data is None or len(processed_data) == 0:
-        return "View 1", None
+        return ("View 1",) + (None,) * (3 if update_fn == update_measure_view else 1)
+
     try:
-        current_view = int(current_selector_value.split()[1]) - 1
+        cur = int(current_selector.split()[1]) - 1
     except Exception:
-        current_view = 0
-    num_views = len(processed_data)
-    new_view = (current_view + direction) % num_views
-    new_selector_value = f"View {new_view + 1}"
-    normal_vis = update_normal_view(processed_data, new_view)
-    return new_selector_value, normal_vis
+        cur = 0
 
+    nv = (cur + direction) % len(processed_data)
+    sel = f"View {nv + 1}"
+    result = update_fn(processed_data, nv)
 
-def navigate_measure_view(processed_data, current_selector_value, direction):
-    """Navigate measure view (direction: -1 for previous, +1 for next)."""
-    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 Exception:
-        current_view = 0
-    num_views = len(processed_data)
-    new_view = (current_view + direction) % num_views
-    new_selector_value = f"View {new_view + 1}"
-    measure_image, measure_points = update_measure_view(processed_data, new_view)
-    return new_selector_value, measure_image, measure_points
+    if isinstance(result, tuple):
+        return (sel,) + result
+    return sel, result
+
+
+def navigate_depth_view(pd, cs, d):
+    return _navigate(pd, cs, d, update_depth_view)
+
+
+def navigate_normal_view(pd, cs, d):
+    return _navigate(pd, cs, d, update_normal_view)
+
+
+def navigate_measure_view(pd, cs, d):
+    return _navigate(pd, cs, d, update_measure_view)
 
 
 def populate_visualization_tabs(processed_data):
-    """Populate the depth, normal, and measure tabs with initial data (view 0)."""
+    """Initial population after reconstruction."""
     if processed_data is None or len(processed_data) == 0:
         return None, None, None, []
     depth_vis = update_depth_view(processed_data, 0)
@@ -412,66 +398,67 @@ def populate_visualization_tabs(processed_data):
     return depth_vis, normal_vis, measure_img, []
 
 
+# ============================================================================
+# Measurement Function
+# ============================================================================
+
+
 def measure(processed_data, measure_points, current_view_selector, event: gr.SelectData):
-    """Handle click-to-measure on images: two clicks → 3D distance."""
+    """Click handler for the Measure tab image."""
     try:
         if processed_data is None or len(processed_data) == 0:
             return None, [], "No data available"
 
-        # Determine which view is currently active
         try:
-            current_view_index = int(current_view_selector.split()[1]) - 1
+            view_idx = int(current_view_selector.split()[1]) - 1
         except Exception:
-            current_view_index = 0
-
-        if current_view_index < 0 or current_view_index >= len(processed_data):
-            current_view_index = 0
-
-        view_keys = list(processed_data.keys())
-        current_view = processed_data[view_keys[current_view_index]]
+            view_idx = 0
+        view_idx = max(0, min(view_idx, len(processed_data) - 1))
 
+        keys = list(processed_data.keys())
+        current_view = processed_data[keys[view_idx]]
         if current_view is None:
             return None, [], "No view data available"
 
-        point2d = event.index[0], event.index[1]
+        point2d = (event.index[0], event.index[1])
 
         # Reject clicks on masked (invalid) areas
         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]
+            and not current_view["mask"][point2d[1], point2d[0]]
         ):
-            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>',
-                )
+            img_masked, _ = update_measure_view(processed_data, view_idx)
+            return (
+                img_masked,
+                measure_points,
+                '<span style="color:red;font-weight:bold;">'
+                "Cannot measure on masked areas (shown in grey)</span>",
+            )
 
         measure_points.append(point2d)
 
-        # Get base image with mask overlay
-        image, _ = update_measure_view(processed_data, current_view_index)
+        image, _ = update_measure_view(processed_data, view_idx)
         if image is None:
             return None, [], "No image available"
-
         image = image.copy()
-        points3d = current_view["points3d"]
 
-        # Ensure uint8
         if image.dtype != np.uint8:
-            if image.max() <= 1.0:
-                image = (image * 255).astype(np.uint8)
-            else:
-                image = image.astype(np.uint8)
+            image = (
+                (image * 255).astype(np.uint8)
+                if image.max() <= 1.0
+                else image.astype(np.uint8)
+            )
+
+        points3d = current_view["points3d"]
 
-        # Draw circles on marked points
+        # Draw circles
         for p in measure_points:
             if 0 <= p[0] < image.shape[1] and 0 <= p[1] < image.shape[0]:
                 image = cv2.circle(image, p, radius=5, color=(255, 0, 0), thickness=2)
 
-        # Build depth info text
+        # Depth text
         depth_text = ""
         for i, p in enumerate(measure_points):
             if (
@@ -489,40 +476,29 @@ def measure(processed_data, measure_points, current_view_selector, event: gr.Sel
                 z = points3d[p[1], p[0], 2]
                 depth_text += f"- **P{i + 1} Z-coord: {z:.2f}m.**\n"
 
-        # If two points are marked, compute distance
         if len(measure_points) == 2:
-            point1, point2 = measure_points
-
-            # Draw line between the two points
+            p1, p2 = 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]
+                0 <= p1[0] < image.shape[1]
+                and 0 <= p1[1] < image.shape[0]
+                and 0 <= p2[0] < image.shape[1]
+                and 0 <= p2[1] < image.shape[0]
             ):
-                image = cv2.line(image, point1, point2, color=(255, 0, 0), thickness=2)
+                image = cv2.line(image, p1, p2, color=(255, 0, 0), thickness=2)
 
-            # Compute 3D Euclidean distance
             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]
+                and 0 <= p1[1] < points3d.shape[0]
+                and 0 <= p1[0] < points3d.shape[1]
+                and 0 <= p2[1] < points3d.shape[0]
+                and 0 <= p2[0] < points3d.shape[1]
             ):
-                try:
-                    p1_3d = points3d[point1[1], point1[0]]
-                    p2_3d = points3d[point2[1], point2[0]]
-                    distance = np.linalg.norm(p1_3d - p2_3d)
-                    distance_text = f"- **Distance: {distance:.2f}m**"
-                except Exception as e:
-                    distance_text = f"- **Distance computation error: {e}**"
+                dist = np.linalg.norm(points3d[p1[1], p1[0]] - points3d[p2[1], p2[0]])
+                distance_text = f"- **Distance: {dist:.2f}m**"
 
-            # Reset points after measurement
-            measure_points = []
-            text = depth_text + distance_text
-            return [image, measure_points, text]
+            measure_points = []  # reset after two-point measurement
+            return [image, measure_points, depth_text + distance_text]
         else:
             return [image, measure_points, depth_text]
 
@@ -531,20 +507,13 @@ def measure(processed_data, measure_points, current_view_selector, event: gr.Sel
         return None, [], f"Measure error: {e}"
 
 
-def reset_measure(processed_data):
-    """Reset measure points and return clean image."""
-    if processed_data is None or len(processed_data) == 0:
-        return None, [], ""
-    first_view = list(processed_data.values())[0]
-    return first_view["image"], [], ""
-
-
 # ============================================================================
-# Helper Functions (KEPT AS-IS)
+# File Handling (Image-only)
 # ============================================================================
 
+
 def handle_uploads(input_images):
-    """Handle uploaded images."""
+    """Copy uploaded images into a unique target_dir/images folder."""
     start_time = time.time()
     gc.collect()
     torch.cuda.empty_cache()
@@ -562,45 +531,48 @@ def handle_uploads(input_images):
 
     if input_images is not None:
         for file_data in input_images:
-            if isinstance(file_data, dict) and "name" in file_data:
-                file_path = file_data["name"]
-            else:
-                file_path = file_data
-
+            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"]:
                 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)
+                        base = os.path.splitext(os.path.basename(file_path))[0]
+                        dst = os.path.join(target_dir_images, f"{base}.jpg")
+                        img.save(dst, "JPEG", quality=95)
+                        image_paths.append(dst)
                 except Exception as e:
                     print(f"Error converting HEIC: {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)
+                    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)
-
-    end_time = time.time()
-    print(f"Files copied to {target_dir_images}; took {end_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):
-    """Update gallery on upload."""
+    """Fired whenever the file input changes."""
     if not input_images:
-        return None, None, None, None
+        return None, None, None, None, None
     target_dir, image_paths = handle_uploads(input_images)
     return (
-        None,
+        None,  # clear raw_3d_output
+        None,  # clear view_3d_output
         target_dir,
         image_paths,
         "Upload complete. Click 'Start Reconstruction' to begin 3D processing.",
@@ -608,9 +580,10 @@ def update_gallery_on_upload(input_images):
 
 
 # ============================================================================
-# Main Reconstruction Function (Extended for new tabs)
+# Main Reconstruction
 # ============================================================================
 
+
 @spaces.GPU(duration=120)
 def gradio_demo(
     target_dir,
@@ -618,48 +591,53 @@ def gradio_demo(
     show_cam=True,
     filter_black_bg=False,
     filter_white_bg=False,
-    conf_thres=3.0,
+    conf_thres=0.0,
     apply_mask=True,
     show_mesh=True,
 ):
-    """Perform reconstruction and populate all tabs."""
-    if not os.path.isdir(target_dir) or target_dir == "None":
-        return (
-            None, None,
-            "Please upload files first",
-            None, None,
-            None, None, None, "",
-            None, None, None,
-        )
+    """Run reconstruction, produce both Raw-3D and 3D-View GLBs, plus per-view data."""
+    empty = (
+        None, None, "Please upload files first",
+        gr.Dropdown(choices=["All"], value="All"),
+        None, None, None, None, "",
+        gr.Dropdown(choices=["View 1"], value="View 1"),
+        gr.Dropdown(choices=["View 1"], value="View 1"),
+        gr.Dropdown(choices=["View 1"], value="View 1"),
+    )
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return empty
 
     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 []
-    all_files_display = [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}: {fn}" for i, fn in enumerate(all_files)]
     frame_filter_choices = ["All"] + all_files_display
 
-    # ---- Run model (KEPT AS-IS) ----
+    # ── Model inference ──────────────────────────────────────────────────
     print("Running MapAnything model...")
     with torch.no_grad():
-        predictions = run_model(target_dir, apply_mask)
+        predictions, processed_data = run_model(
+            target_dir, apply_mask, filter_black_bg, filter_white_bg
+        )
 
-    # ---- Save predictions (KEPT AS-IS) ----
-    prediction_save_path = os.path.join(target_dir, "predictions.npz")
-    np.savez(prediction_save_path, **predictions)
+    # Save predictions for later re-visualisation
+    np.savez(os.path.join(target_dir, "predictions.npz"), **predictions)
 
     if frame_filter is None:
         frame_filter = "All"
 
-    # ---- Generate GLB (KEPT AS-IS) ----
-    glbfile = os.path.join(
-        target_dir,
-        f"glbscene_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_mesh{show_mesh}.glb",
-    )
+    ff_safe = frame_filter.replace(".", "").replace(":", "").replace(" ", "")
 
-    glbscene = predictions_to_glb(
+    # ── Raw 3D GLB (viz module, with conf_percentile) ────────────────────
+    raw_glb_path = os.path.join(target_dir, f"raw_{ff_safe}_cam{show_cam}_mesh{show_mesh}.glb")
+    raw_scene = predictions_to_glb_raw(
         predictions,
         filter_by_frames=frame_filter,
         show_cam=show_cam,
@@ -668,87 +646,87 @@ def gradio_demo(
         as_mesh=show_mesh,
         conf_percentile=conf_thres,
     )
-    glbscene.export(file_obj=glbfile)
+    raw_scene.export(file_obj=raw_glb_path)
 
-    # ---- NEW: Process data for Depth / Normal / Measure tabs ----
-    processed_data = process_predictions_for_visualization(
-        predictions, filter_black_bg, filter_white_bg
+    # ── 3D View GLB (visual_util module, no conf_percentile) ─────────────
+    view_glb_path = os.path.join(target_dir, f"view_{ff_safe}_cam{show_cam}_mesh{show_mesh}.glb")
+    view_scene = predictions_to_glb_view(
+        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,
     )
+    view_scene.export(file_obj=view_glb_path)
+
+    # ── Populate per-view tabs ───────────────────────────────────────────
     depth_vis, normal_vis, measure_img, _ = populate_visualization_tabs(processed_data)
-    depth_selector, normal_selector, measure_selector = update_view_selectors(processed_data)
+    depth_sel, normal_sel, measure_sel = update_view_selectors(processed_data)
 
     # Cleanup
     del predictions
     gc.collect()
     torch.cuda.empty_cache()
 
-    end_time = time.time()
-    print(f"Total time elapsed: {end_time - start_time:.2f} seconds")
-    log_msg = f"✅ Reconstruction successful ({len(all_files)} frames)"
+    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,                                                                      # reconstruction_output  (Raw 3D)
-        glbfile,                                                                      # reconstruction_output_3d (3D View)
-        log_msg,                                                                      # log_output
-        gr.Dropdown(choices=frame_filter_choices, value=frame_filter, interactive=True),  # frame_filter
-        processed_data,                                                               # processed_data_state
-        depth_vis,                                                                    # depth_map
-        normal_vis,                                                                   # normal_map
-        measure_img,                                                                  # measure_image
-        "",                                                                           # measure_text
-        depth_selector,                                                               # depth_view_selector
-        normal_selector,                                                              # normal_view_selector
-        measure_selector,                                                             # measure_view_selector
+        raw_glb_path,                                                       # raw_3d_output
+        view_glb_path,                                                      # view_3d_output
+        log_msg,                                                            # log_output
+        gr.Dropdown(choices=frame_filter_choices, value=frame_filter,
+                    interactive=True),                                      # frame_filter
+        processed_data,                                                     # processed_data_state
+        depth_vis,                                                          # depth_map
+        normal_vis,                                                         # normal_map
+        measure_img,                                                        # measure_image
+        "",                                                                 # measure_text
+        depth_sel,                                                          # depth_view_selector
+        normal_sel,                                                         # normal_view_selector
+        measure_sel,                                                        # measure_view_selector
     )
 
 
 # ============================================================================
-# UI Helper Functions
+# Live Re-visualisation (from saved predictions)
 # ============================================================================
 
+
 def clear_fields():
-    """Clear 3D viewer."""
-    return None
+    return None, None
 
 
 def update_log():
-    """Display log message while processing."""
-    return "Loading and reconstructing..."
+    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,
+def update_raw_3d_visualization(
+    target_dir, frame_filter, show_cam, is_example,
+    conf_thres=0.0, filter_black_bg=False, filter_white_bg=False, show_mesh=True,
 ):
-    """
-    Reload saved predictions from npz, create (or reuse) the GLB for new parameters.
-    KEPT AS-IS from original code.
-    """
+    """Re-build the Raw 3D GLB from saved predictions."""
     if is_example == "True":
-        return gr.update(), "No reconstruction available. Please click the reconstruct button first."
-
+        return gr.update(), "No reconstruction available."
     if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
-        return gr.update(), "No reconstruction available. Please click the reconstruct button first."
+        return gr.update(), "No reconstruction available."
 
-    predictions_path = os.path.join(target_dir, "predictions.npz")
-    if not os.path.exists(predictions_path):
-        return gr.update(), f"No reconstruction available. Please run 'Start Reconstruction' first."
+    pred_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(pred_path):
+        return gr.update(), "Run 'Start Reconstruction' first."
 
-    loaded = np.load(predictions_path, allow_pickle=True)
-    predictions = {key: loaded[key] for key in loaded.keys()}
+    predictions = dict(np.load(pred_path, allow_pickle=True))
 
-    glbfile = os.path.join(
+    ff_safe = frame_filter.replace(".", "").replace(":", "").replace(" ", "")
+    glb = 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",
+        f"raw_{ff_safe}_cam{show_cam}_mesh{show_mesh}_conf{conf_thres}"
+        f"_b{filter_black_bg}_w{filter_white_bg}.glb",
     )
 
-    glbscene = predictions_to_glb(
+    scene = predictions_to_glb_raw(
         predictions,
         filter_by_frames=frame_filter,
         show_cam=show_cam,
@@ -757,184 +735,158 @@ def update_visualization(
         as_mesh=show_mesh,
         conf_percentile=conf_thres,
     )
-    glbscene.export(file_obj=glbfile)
-
-    return glbfile, "Visualization updated."
+    scene.export(file_obj=glb)
+    return glb, "Raw 3D updated."
 
 
-def update_all_3d_views(
+def update_3d_view_visualization(
     target_dir, frame_filter, show_cam, is_example,
-    conf_thres, filter_black_bg, filter_white_bg, show_mesh,
+    filter_black_bg=False, filter_white_bg=False, show_mesh=True,
 ):
-    """Wrapper: update both Raw 3D and 3D View tabs simultaneously."""
-    glb_result, log_msg = update_visualization(
-        target_dir, frame_filter, show_cam, is_example,
-        conf_thres, filter_black_bg, filter_white_bg, show_mesh,
+    """Re-build the 3D View GLB from saved predictions."""
+    if is_example == "True":
+        return gr.update(), "No reconstruction available."
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return gr.update(), "No reconstruction available."
+
+    pred_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(pred_path):
+        return gr.update(), "Run 'Start Reconstruction' first."
+
+    predictions = dict(np.load(pred_path, allow_pickle=True))
+
+    ff_safe = frame_filter.replace(".", "").replace(":", "").replace(" ", "")
+    glb = os.path.join(
+        target_dir,
+        f"view_{ff_safe}_cam{show_cam}_mesh{show_mesh}"
+        f"_b{filter_black_bg}_w{filter_white_bg}.glb",
+    )
+
+    scene = predictions_to_glb_view(
+        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,
     )
-    return glb_result, glb_result, log_msg
+    scene.export(file_obj=glb)
+    return glb, "3D View updated."
 
 
 def update_all_views_on_filter_change(
-    target_dir, filter_black_bg, filter_white_bg, processed_data,
+    target_dir, filter_black_bg, filter_white_bg,
+    processed_data,
     depth_view_selector, normal_view_selector, measure_view_selector,
 ):
-    """
-    Re-process per-view visualization (depth / normal / measure) when
-    background filter checkboxes change.
-    """
+    """Re-process per-view data when background filters 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):
+    pred_path = os.path.join(target_dir, "predictions.npz")
+    if not os.path.exists(pred_path):
         return processed_data, None, None, None, []
 
     try:
-        loaded = np.load(predictions_path, allow_pickle=True)
-        predictions = {key: loaded[key] for key in loaded.keys()}
+        predictions = dict(np.load(pred_path, allow_pickle=True))
+        views = load_images(os.path.join(target_dir, "images"))
 
-        new_processed_data = process_predictions_for_visualization(
-            predictions, filter_black_bg, filter_white_bg
+        new_pd = process_predictions_for_visualization(
+            predictions, views, high_level_config, filter_black_bg, filter_white_bg
         )
 
-        # Determine current view indices
-        try:
-            depth_idx = int(depth_view_selector.split()[1]) - 1 if depth_view_selector else 0
-        except Exception:
-            depth_idx = 0
-        try:
-            normal_idx = int(normal_view_selector.split()[1]) - 1 if normal_view_selector else 0
-        except Exception:
-            normal_idx = 0
-        try:
-            measure_idx = int(measure_view_selector.split()[1]) - 1 if measure_view_selector else 0
-        except Exception:
-            measure_idx = 0
-
-        depth_vis = update_depth_view(new_processed_data, depth_idx)
-        normal_vis = update_normal_view(new_processed_data, normal_idx)
-        measure_img, _ = update_measure_view(new_processed_data, measure_idx)
+        def _idx(sel):
+            try:
+                return int(sel.split()[1]) - 1
+            except Exception:
+                return 0
 
-        return new_processed_data, depth_vis, normal_vis, measure_img, []
+        d_vis = update_depth_view(new_pd, _idx(depth_view_selector))
+        n_vis = update_normal_view(new_pd, _idx(normal_view_selector))
+        m_img, _ = update_measure_view(new_pd, _idx(measure_view_selector))
+        return new_pd, d_vis, n_vis, m_img, []
 
     except Exception as e:
-        print(f"Error updating views on filter change: {e}")
+        print(f"Error updating views: {e}")
         return processed_data, None, None, None, []
 
 
 # ============================================================================
-# Example Scenes (KEPT AS-IS)
+# Example Scenes
 # ============================================================================
 
+
 def get_scene_info(examples_dir):
-    """Get information about scenes in the examples directory."""
     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_extensions = ["*.jpg", "*.jpeg", "*.png", "*.bmp", "*.tiff", "*.tif"]
-            image_files = []
-            for ext in image_extensions:
-                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)
-                first_image = image_files[0]
-                num_images = len(image_files)
-
-                scenes.append(
-                    {
-                        "name": scene_folder,
-                        "path": scene_path,
-                        "thumbnail": first_image,
-                        "num_images": num_images,
-                        "image_files": image_files,
-                    }
-                )
-
+    for folder in sorted(os.listdir(examples_dir)):
+        path = os.path.join(examples_dir, folder)
+        if not os.path.isdir(path):
+            continue
+        exts = [".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif"]
+        files = []
+        for ext in exts:
+            files.extend(glob.glob(os.path.join(path, f"*{ext}")))
+            files.extend(glob.glob(os.path.join(path, f"*{ext.upper()}")))
+        if files:
+            files = sorted(files)
+            scenes.append(
+                {
+                    "name": folder,
+                    "path": path,
+                    "thumbnail": files[0],
+                    "num_images": len(files),
+                    "image_files": files,
+                }
+            )
     return scenes
 
 
 def load_example_scene(scene_name, examples_dir="examples"):
-    """Load a scene from examples directory."""
     scenes = get_scene_info(examples_dir)
-
-    selected_scene = None
-    for scene in scenes:
-        if scene["name"] == scene_name:
-            selected_scene = scene
-            break
-
-    if selected_scene is None:
-        return None, None, None, "Scene not found"
-
-    target_dir, image_paths = handle_uploads(selected_scene["image_files"])
-
+    selected = next((s for s in scenes if s["name"] == scene_name), None)
+    if selected is None:
+        return None, None, None, None, "Scene not found"
+    target_dir, image_paths = handle_uploads(selected["image_files"])
     return (
+        None,
         None,
         target_dir,
         image_paths,
-        f"Loaded scene '{scene_name}' ({selected_scene['num_images']} images). Click 'Start Reconstruction' to begin 3D processing.",
+        f"Loaded scene '{scene_name}' ({selected['num_images']} images). "
+        "Click 'Start Reconstruction' to begin.",
     )
 
 
 # ============================================================================
-# Gradio UI — 5 Tabs: Raw 3D · 3D View · Depth · Normal · Measure
+# Gradio UI
 # ============================================================================
 
 theme = get_gradio_theme()
 
 APP_CSS = GRADIO_CSS + """
-/* Prevent components from expanding the layout */
-.gradio-container {
-    max-width: 100% !important;
-}
-
-/* Fixed height for Gallery */
-.gallery-container {
-    max-height: 350px !important;
-    overflow-y: auto !important;
-}
-
-/* Fixed height for File component */
-.file-preview {
-    max-height: 200px !important;
-    overflow-y: auto !important;
-}
-
-/* Prevent Textbox from expanding infinitely */
-.textbox-container {
-    max-height: 100px !important;
-}
-
-/* Keep Tabs content area stable */
-.tab-content {
-    min-height: 550px !important;
-}
-
-/* Navigation row styling */
-.navigation-row {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-}
+.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; }
+.tab-content { min-height: 550px !important; }
 """
 
-with gr.Blocks() as demo:
-    # Hidden state variables
+with gr.Blocks(theme=theme, css=APP_CSS) as demo:
+
+    # ── Hidden state ────────────────────────────────────────────────────
     is_example = gr.Textbox(label="is_example", visible=False, value="None")
     target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
     processed_data_state = gr.State(value=None)
     measure_points_state = gr.State(value=[])
 
+    # ── Layout ──────────────────────────────────────────────────────────
     with gr.Row(equal_height=False):
-        # ==================== Left Side: Input Area ====================
+
+        # ---- Left column: inputs ----
         with gr.Column(scale=1, min_width=300):
             gr.Markdown("### 📤 Input")
 
@@ -963,33 +915,33 @@ with gr.Blocks() as demo:
                     scale=1,
                 )
 
-        # ==================== Right Side: Output Area ====================
+        # ---- Right column: outputs ----
         with gr.Column(scale=2, min_width=600):
             gr.Markdown("### 🎯 Output")
 
             with gr.Tabs():
-                # ---------- Tab 1: Raw 3D (KEPT AS-IS) ----------
+                # ── Tab 1: Raw 3D ────────────────────────────────────────
                 with gr.Tab("🏗️ Raw 3D"):
-                    reconstruction_output = gr.Model3D(
+                    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 (NEW) ----------
-                with gr.Tab("🌐 3D View"):
-                    reconstruction_output_3d = gr.Model3D(
+                # ── Tab 2: 3D View ───────────────────────────────────────
+                with gr.Tab("🔭 3D View"):
+                    view_3d_output = gr.Model3D(
                         height=550,
                         zoom_speed=0.5,
                         pan_speed=0.5,
-                        clear_color=[0.05, 0.05, 0.05, 1.0],
+                        clear_color=[0.0, 0.0, 0.0, 0.0],
                     )
 
-                # ---------- Tab 3: Depth (NEW) ----------
-                with gr.Tab("🔵 Depth"):
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_depth_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                # ── 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",
@@ -1006,10 +958,10 @@ with gr.Blocks() as demo:
                         interactive=False,
                     )
 
-                # ---------- Tab 4: Normal (NEW) ----------
-                with gr.Tab("🟢 Normal"):
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_normal_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                # ── 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",
@@ -1026,11 +978,11 @@ with gr.Blocks() as demo:
                         interactive=False,
                     )
 
-                # ---------- Tab 5: Measure (NEW) ----------
-                with gr.Tab("📏 Measure"):
+                # ── Tab 5: Measure ───────────────────────────────────────
+                with gr.Tab("📐 Measure"):
                     gr.Markdown(MEASURE_INSTRUCTIONS_HTML)
-                    with gr.Row(elem_classes=["navigation-row"]):
-                        prev_measure_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                    with gr.Row():
+                        prev_measure_btn = gr.Button("◀ Previous", size="sm", scale=1)
                         measure_view_selector = gr.Dropdown(
                             choices=["View 1"],
                             value="View 1",
@@ -1048,7 +1000,8 @@ with gr.Blocks() as demo:
                         sources=[],
                     )
                     gr.Markdown(
-                        "**Note:** Light-grey areas indicate regions with no depth information where measurements cannot be taken."
+                        "**Note:** Light-grey areas indicate regions with no "
+                        "depth information where measurements cannot be taken."
                     )
                     measure_text = gr.Markdown("")
 
@@ -1060,11 +1013,11 @@ with gr.Blocks() as demo:
                 max_lines=1,
             )
 
-    # ==================== Advanced Options (Collapsible) ====================
+    # ── 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")
+                gr.Markdown("#### Visualisation Parameters")
                 frame_filter = gr.Dropdown(
                     choices=["All"], value="All", label="Display Frame"
                 )
@@ -1073,7 +1026,7 @@ with gr.Blocks() as demo:
                     maximum=100,
                     value=0,
                     step=0.1,
-                    label="Confidence Threshold (Percentile)",
+                    label="Confidence Threshold – Percentile (Raw 3D only)",
                 )
                 show_cam = gr.Checkbox(label="Show Camera", value=True)
                 show_mesh = gr.Checkbox(label="Show Mesh", value=True)
@@ -1083,23 +1036,22 @@ with gr.Blocks() as demo:
                 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 (Collapsible) ====================
+    # ── 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):
-                        scene_idx = i + j
-                        if scene_idx < len(scenes):
-                            scene = scenes[scene_idx]
+                        idx = i + j
+                        if idx < len(scenes):
+                            scene = scenes[idx]
                             with gr.Column(scale=1, min_width=150):
                                 scene_img = gr.Image(
                                     value=scene["thumbnail"],
@@ -1110,44 +1062,46 @@ with gr.Blocks() as demo:
                                     container=False,
                                 )
                                 gr.Markdown(
-                                    f"**{scene['name']}** ({scene['num_images']} images)",
-                                    elem_classes=["text-center"],
+                                    f"{scene['name']} ({scene['num_images']} images)"
                                 )
                                 scene_img.select(
                                     fn=lambda name=scene["name"]: load_example_scene(
                                         name
                                     ),
                                     outputs=[
-                                        reconstruction_output,
+                                        raw_3d_output,
+                                        view_3d_output,
                                         target_dir_output,
                                         image_gallery,
                                         log_output,
                                     ],
                                 )
 
-    # ====================================================================
-    # Event Binding
-    # ====================================================================
+    # ── Optional acknowledgements ───────────────────────────────────────
+    if get_acknowledgements_html is not None:
+        gr.HTML(get_acknowledgements_html())
 
-    # ---- Auto-update gallery on file upload ----
+    # ================================================================
+    # EVENT BINDINGS
+    # ================================================================
+
+    # ── Upload ──────────────────────────────────────────────────────────
     input_images.change(
         fn=update_gallery_on_upload,
         inputs=[input_images],
         outputs=[
-            reconstruction_output,
+            raw_3d_output,
+            view_3d_output,
             target_dir_output,
             image_gallery,
             log_output,
         ],
-    ).then(
-        fn=lambda: None,
-        outputs=[reconstruction_output_3d],
     )
 
-    # ---- Reconstruction button ----
+    # ── Reconstruct ─────────────────────────────────────────────────────
     submit_btn.click(
-        fn=lambda: (None, None),
-        outputs=[reconstruction_output, reconstruction_output_3d],
+        fn=clear_fields,
+        outputs=[raw_3d_output, view_3d_output],
     ).then(
         fn=update_log,
         outputs=[log_output],
@@ -1164,8 +1118,8 @@ with gr.Blocks() as demo:
             show_mesh,
         ],
         outputs=[
-            reconstruction_output,       # Raw 3D
-            reconstruction_output_3d,    # 3D View
+            raw_3d_output,
+            view_3d_output,
             log_output,
             frame_filter,
             processed_data_state,
@@ -1182,49 +1136,55 @@ with gr.Blocks() as demo:
         outputs=[is_example],
     )
 
-    # ---- Clear button: also clear new tabs ----
-    clear_btn.add([reconstruction_output, reconstruction_output_3d, log_output])
+    # ── Clear button ────────────────────────────────────────────────────
+    clear_btn.add([raw_3d_output, view_3d_output, log_output])
 
-    # ---- 3D visualization param changes (frame_filter, show_cam, conf, mesh) ----
-    for component in [frame_filter, show_cam, conf_thres, show_mesh]:
+    # ── Live updates: frame_filter / show_cam / show_mesh ───────────────
+    # These affect both Raw 3D and 3D View
+    for component in [frame_filter, show_cam, show_mesh]:
         component.change(
-            fn=update_all_3d_views,
+            fn=update_raw_3d_visualization,
             inputs=[
-                target_dir_output,
-                frame_filter,
-                show_cam,
-                is_example,
-                conf_thres,
-                filter_black_bg,
-                filter_white_bg,
-                show_mesh,
+                target_dir_output, frame_filter, show_cam, is_example,
+                conf_thres, filter_black_bg, filter_white_bg, show_mesh,
             ],
-            outputs=[
-                reconstruction_output,
-                reconstruction_output_3d,
-                log_output,
+            outputs=[raw_3d_output, log_output],
+        ).then(
+            fn=update_3d_view_visualization,
+            inputs=[
+                target_dir_output, frame_filter, show_cam, is_example,
+                filter_black_bg, filter_white_bg, show_mesh,
             ],
+            outputs=[view_3d_output, log_output],
         )
 
-    # ---- Background filter changes: update 3D viewers AND per-view tabs ----
-    for filter_component in [filter_black_bg, filter_white_bg]:
-        filter_component.change(
-            fn=update_all_3d_views,
+    # ── Live update: conf_thres (Raw 3D only) ──────────────────────────
+    conf_thres.change(
+        fn=update_raw_3d_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, log_output],
+    )
+
+    # ── Live updates: background filters ────────────────────────────────
+    # These affect Raw 3D, 3D View, AND Depth/Normal/Measure tabs
+    for bg_filter in [filter_black_bg, filter_white_bg]:
+        bg_filter.change(
+            fn=update_raw_3d_visualization,
             inputs=[
-                target_dir_output,
-                frame_filter,
-                show_cam,
-                is_example,
-                conf_thres,
-                filter_black_bg,
-                filter_white_bg,
-                show_mesh,
+                target_dir_output, frame_filter, show_cam, is_example,
+                conf_thres, filter_black_bg, filter_white_bg, show_mesh,
             ],
-            outputs=[
-                reconstruction_output,
-                reconstruction_output_3d,
-                log_output,
+            outputs=[raw_3d_output, log_output],
+        ).then(
+            fn=update_3d_view_visualization,
+            inputs=[
+                target_dir_output, frame_filter, show_cam, is_example,
+                filter_black_bg, filter_white_bg, show_mesh,
             ],
+            outputs=[view_3d_output, log_output],
         ).then(
             fn=update_all_views_on_filter_change,
             inputs=[
@@ -1245,7 +1205,7 @@ with gr.Blocks() as demo:
             ],
         )
 
-    # ---- Depth tab navigation ----
+    # ── Depth tab navigation ───────────────────────────────────────────
     prev_depth_btn.click(
         fn=lambda pd, cs: navigate_depth_view(pd, cs, -1),
         inputs=[processed_data_state, depth_view_selector],
@@ -1264,7 +1224,7 @@ with gr.Blocks() as demo:
         outputs=[depth_map],
     )
 
-    # ---- Normal tab navigation ----
+    # ── Normal tab navigation ──────────────────────────────────────────
     prev_normal_btn.click(
         fn=lambda pd, cs: navigate_normal_view(pd, cs, -1),
         inputs=[processed_data_state, normal_view_selector],
@@ -1283,7 +1243,7 @@ with gr.Blocks() as demo:
         outputs=[normal_map],
     )
 
-    # ---- Measure tab navigation ----
+    # ── Measure tab navigation ─────────────────────────────────────────
     prev_measure_btn.click(
         fn=lambda pd, cs: navigate_measure_view(pd, cs, -1),
         inputs=[processed_data_state, measure_view_selector],
@@ -1304,7 +1264,7 @@ with gr.Blocks() as demo:
         outputs=[measure_image, measure_points_state],
     )
 
-    # ---- Measure click handler ----
+    # ── Measure click ──────────────────────────────────────────────────
     measure_image.select(
         fn=measure,
         inputs=[processed_data_state, measure_points_state, measure_view_selector],