Update app.py

app.py

@@ -16,12 +16,12 @@ import torch
 from PIL import Image
 from pillow_heif import register_heif_opener
 
-# --- Rerun Imports ---
 import rerun as rr
 try:
     import rerun.blueprint as rrb
 except ImportError:
     rrb = None
+
 from gradio_rerun import Rerun
 
 register_heif_opener()
@@ -41,10 +41,9 @@ 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
 
-# MapAnything Configuration
 high_level_config = {
     "path": "configs/train.yaml",
-    "hf_model_name": "facebook/map-anything-v1",  # -- facebook/map-anything
+    "hf_model_name": "facebook/map-anything-v1",
     "model_str": "mapanything",
     "config_overrides": [
         "machine=aws",
@@ -61,37 +60,31 @@ high_level_config = {
     "resolution": 518,
 }
 
-# Initialize model - this will be done on GPU when needed
 model = None
+TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
+os.makedirs(TMP_DIR, exist_ok=True)
 
 
 # -------------------------------------------------------------------------
-# Rerun Helper Function
+# Rerun visualization helper
 # -------------------------------------------------------------------------
-def create_rerun_recording(glb_path, output_dir):
-    """
-    Takes a generated GLB file, wraps it in a Rerun recording (.rrd), 
-    and returns the path to the .rrd file for the UI to consume.
-    """
+def predictions_to_rrd(predictions, glbfile, target_dir, frame_filter="All", show_cam=True):
     run_id = str(uuid.uuid4())
-    
-    # Robustly handle different Rerun SDK versions
+    timestamp = datetime.now().strftime("%Y-%m-%dT%H%M%S")
+    rrd_path = os.path.join(target_dir, f"mapanything_{timestamp}.rrd")
+
     rec = None
     if hasattr(rr, "new_recording"):
-        rec = rr.new_recording(application_id="MapAnything-3D", recording_id=run_id)
+        rec = rr.new_recording(application_id="MapAnything-3D-Viewer", recording_id=run_id)
     elif hasattr(rr, "RecordingStream"):
-        rec = rr.RecordingStream(application_id="MapAnything-3D", recording_id=run_id)
+        rec = rr.RecordingStream(application_id="MapAnything-3D-Viewer", recording_id=run_id)
     else:
-        rr.init("MapAnything-3D", recording_id=run_id, spawn=False)
+        rr.init("MapAnything-3D-Viewer", recording_id=run_id, spawn=False)
         rec = rr
-        
-    # Clear previous states
+
     rec.log("world", rr.Clear(recursive=True), static=True)
-    
-    # Set coordinates
     rec.log("world", rr.ViewCoordinates.RIGHT_HAND_Y_UP, static=True)
 
-    # Add optional axes helpers
     try:
         rec.log("world/axes/x", rr.Arrows3D(vectors=[[0.5, 0, 0]], colors=[[255, 0, 0]]), static=True)
         rec.log("world/axes/y", rr.Arrows3D(vectors=[[0, 0.5, 0]], colors=[[0, 255, 0]]), static=True)
@@ -99,27 +92,78 @@ def create_rerun_recording(glb_path, output_dir):
     except Exception:
         pass
 
-    # Log the 3D Model
-    rec.log("world/scene", rr.Asset3D(path=glb_path), static=True)
-    
-    # Blueprint for clean layout
+    rec.log("world/model", rr.Asset3D(path=glbfile), static=True)
+
+    if show_cam and "extrinsic" in predictions and "intrinsic" in predictions:
+        try:
+            extrinsics = predictions["extrinsic"]
+            intrinsics = predictions["intrinsic"]
+            for i, (ext, intr) in enumerate(zip(extrinsics, intrinsics)):
+                translation = ext[:3, 3]
+                rotation_mat = ext[:3, :3]
+                rec.log(
+                    f"world/cameras/cam_{i:03d}",
+                    rr.Transform3D(translation=translation, mat3x3=rotation_mat),
+                    static=True,
+                )
+                fx, fy = intr[0, 0], intr[1, 1]
+                cx, cy = intr[0, 2], intr[1, 2]
+                if "images" in predictions and i < len(predictions["images"]):
+                    h, w = predictions["images"][i].shape[:2]
+                else:
+                    h, w = 518, 518
+                rec.log(
+                    f"world/cameras/cam_{i:03d}/image",
+                    rr.Pinhole(focal_length=[fx, fy], principal_point=[cx, cy], width=w, height=h),
+                    static=True,
+                )
+                if "images" in predictions and i < len(predictions["images"]):
+                    img = predictions["images"][i]
+                    if img.dtype != np.uint8:
+                        img = (np.clip(img, 0, 1) * 255).astype(np.uint8)
+                    rec.log(f"world/cameras/cam_{i:03d}/image/rgb", rr.Image(img), static=True)
+        except Exception as e:
+            print(f"Camera logging failed (non-fatal): {e}")
+
+    if "world_points" in predictions and "images" in predictions:
+        try:
+            world_points = predictions["world_points"]
+            images = predictions["images"]
+            final_mask = predictions.get("final_mask")
+            all_points, all_colors = [], []
+            for i in range(len(world_points)):
+                pts = world_points[i]
+                img = images[i]
+                mask = final_mask[i].astype(bool) if final_mask is not None else np.ones(pts.shape[:2], dtype=bool)
+                pts_flat = pts[mask]
+                img_flat = img[mask]
+                if img_flat.dtype != np.uint8:
+                    img_flat = (np.clip(img_flat, 0, 1) * 255).astype(np.uint8)
+                all_points.append(pts_flat)
+                all_colors.append(img_flat)
+            if all_points:
+                all_points = np.concatenate(all_points, axis=0)
+                all_colors = np.concatenate(all_colors, axis=0)
+                max_pts = 500_000
+                if len(all_points) > max_pts:
+                    idx = np.random.choice(len(all_points), max_pts, replace=False)
+                    all_points = all_points[idx]
+                    all_colors = all_colors[idx]
+                rec.log("world/point_cloud", rr.Points3D(positions=all_points, colors=all_colors, radii=0.002), static=True)
+        except Exception as e:
+            print(f"Point cloud logging failed (non-fatal): {e}")
+
     if rrb is not None:
         try:
             blueprint = rrb.Blueprint(
-                rrb.Spatial3DView(
-                    origin="/world",
-                    name="3D View",
-                ),
+                rrb.Spatial3DView(origin="/world", name="3D View"),
                 collapse_panels=True,
             )
             rec.send_blueprint(blueprint)
         except Exception as e:
             print(f"Blueprint creation failed (non-fatal): {e}")
 
-    # Save the recording to the target directory
-    rrd_path = os.path.join(output_dir, f'scene_{run_id}.rrd')
     rec.save(rrd_path)
-    
     return rrd_path
 
 
@@ -127,448 +171,221 @@ def create_rerun_recording(glb_path, output_dir):
 # 1) Core model inference
 # -------------------------------------------------------------------------
 @spaces.GPU(duration=120)
-def run_model(
-    target_dir,
-    apply_mask=True,
-    mask_edges=True,
-    filter_black_bg=False,
-    filter_white_bg=False,
-):
-    """
-    Run the MapAnything model on images in the 'target_dir/images' folder and return predictions.
-    """
+def run_model(target_dir, apply_mask=True, mask_edges=True, filter_black_bg=False, filter_white_bg=False):
     global model
-    import torch  # Ensure torch is available in function scope
+    import torch
 
     print(f"Processing images from {target_dir}")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-    # Device check
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    device = torch.device(device)
-
-    # Initialize model if not already done
     if model is None:
         model = initialize_mapanything_model(high_level_config, device)
-
     else:
         model = model.to(device)
-
     model.eval()
 
-    # Load images using MapAnything's load_images function
     print("Loading images...")
     image_folder_path = os.path.join(target_dir, "images")
     views = load_images(image_folder_path)
-
     print(f"Loaded {len(views)} images")
     if len(views) == 0:
         raise ValueError("No images found. Check your upload.")
 
-    # Run model inference
     print("Running inference...")
-    # apply_mask: Whether to apply the non-ambiguous mask to the output. Defaults to True.
-    # mask_edges: Whether to compute an edge mask based on normals and depth and apply it to the output. Defaults to True.
-    # Use checkbox values - mask_edges is set to True by default since there's no UI control for it
-    outputs = model.infer(
-        views, apply_mask=apply_mask, mask_edges=True, memory_efficient_inference=False
-    )
+    outputs = model.infer(views, apply_mask=apply_mask, mask_edges=True, memory_efficient_inference=False)
 
-    # Convert predictions to format expected by visualization
     predictions = {}
+    extrinsic_list, intrinsic_list, world_points_list = [], [], []
+    depth_maps_list, images_list, final_mask_list = [], [], []
 
-    # Initialize lists for the required keys
-    extrinsic_list = []
-    intrinsic_list = []
-    world_points_list = []
-    depth_maps_list = []
-    images_list = []
-    final_mask_list = []
-
-    # Loop through the outputs
     for pred in outputs:
-        # Extract data from predictions
-        depthmap_torch = pred["depth_z"][0].squeeze(-1)  # (H, W)
-        intrinsics_torch = pred["intrinsics"][0]  # (3, 3)
-        camera_pose_torch = pred["camera_poses"][0]  # (4, 4)
-
-        # Compute new pts3d using depth, intrinsics, and camera pose
-        pts3d_computed, valid_mask = depthmap_to_world_frame(
-            depthmap_torch, intrinsics_torch, camera_pose_torch
-        )
-
-        # Convert to numpy arrays for visualization
-        # Check if mask key exists in pred, if not, fill with boolean trues in the size of depthmap_torch
-        if "mask" in pred:
-            mask = pred["mask"][0].squeeze(-1).cpu().numpy().astype(bool)
-        else:
-            # Fill with boolean trues in the size of depthmap_torch
-            mask = np.ones_like(depthmap_torch.cpu().numpy(), dtype=bool)
-
-        # Combine with valid depth mask
+        depthmap_torch = pred["depth_z"][0].squeeze(-1)
+        intrinsics_torch = pred["intrinsics"][0]
+        camera_pose_torch = pred["camera_poses"][0]
+        pts3d_computed, valid_mask = depthmap_to_world_frame(depthmap_torch, intrinsics_torch, camera_pose_torch)
+        mask = pred["mask"][0].squeeze(-1).cpu().numpy().astype(bool) if "mask" in pred else np.ones_like(depthmap_torch.cpu().numpy(), dtype=bool)
         mask = mask & valid_mask.cpu().numpy()
-
         image = pred["img_no_norm"][0].cpu().numpy()
-
-        # Append to lists
         extrinsic_list.append(camera_pose_torch.cpu().numpy())
         intrinsic_list.append(intrinsics_torch.cpu().numpy())
         world_points_list.append(pts3d_computed.cpu().numpy())
         depth_maps_list.append(depthmap_torch.cpu().numpy())
-        images_list.append(image)  # Add image to list
-        final_mask_list.append(mask)  # Add final_mask to list
+        images_list.append(image)
+        final_mask_list.append(mask)
 
-    # Convert lists to numpy arrays with required shapes
-    # extrinsic: (S, 3, 4) - batch of camera extrinsic matrices
     predictions["extrinsic"] = np.stack(extrinsic_list, axis=0)
-
-    # intrinsic: (S, 3, 3) - batch of camera intrinsic matrices
     predictions["intrinsic"] = np.stack(intrinsic_list, axis=0)
-
-    # world_points: (S, H, W, 3) - batch of 3D world points
     predictions["world_points"] = np.stack(world_points_list, axis=0)
-
-    # depth: (S, H, W, 1) or (S, H, W) - batch of depth maps
     depth_maps = np.stack(depth_maps_list, axis=0)
-    # Add channel dimension if needed to match (S, H, W, 1) format
     if len(depth_maps.shape) == 3:
         depth_maps = depth_maps[..., np.newaxis]
-
     predictions["depth"] = depth_maps
-
-    # images: (S, H, W, 3) - batch of input images
     predictions["images"] = np.stack(images_list, axis=0)
-
-    # final_mask: (S, H, W) - batch of final masks for filtering
     predictions["final_mask"] = np.stack(final_mask_list, axis=0)
 
-    # Process data for visualization tabs (depth, normal, measure)
-    processed_data = process_predictions_for_visualization(
-        predictions, views, high_level_config, filter_black_bg, filter_white_bg
-    )
-
-    # Clean up
+    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
 
 
 def update_view_selectors(processed_data):
-    """Update view selector dropdowns based on available 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))] if processed_data else ["View 1"]
     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"""
-    if processed_data is None or len(processed_data) == 0:
+    if not processed_data:
         return None
-
     view_keys = list(processed_data.keys())
-    if view_index < 0 or view_index >= len(view_keys):
-        view_index = 0
-
+    view_index = max(0, min(view_index, len(view_keys) - 1))
     return processed_data[view_keys[view_index]]
 
 
 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:
         return None
-
     return colorize_depth(view_data["depth"], mask=view_data.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:
         return None
-
     return colorize_normal(view_data["normal"], mask=view_data.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 None, []  # image, measure_points
-
-    # Get the base image
+        return None, []
     image = view_data["image"].copy()
-
-    # Ensure image is in uint8 format
     if image.dtype != np.uint8:
-        if image.max() <= 1.0:
-            image = (image * 255).astype(np.uint8)
-        else:
-            image = image.astype(np.uint8)
-
-    # Apply mask overlay if mask is available
+        image = (image * 255).astype(np.uint8) if image.max() <= 1.0 else image.astype(np.uint8)
     if view_data["mask"] is not None:
-        mask = view_data["mask"]
-
-        # Create light grey overlay for masked areas
-        # Masked areas (False values) will be overlaid with light grey
-        invalid_mask = ~mask  # Areas where mask is False
-
+        invalid_mask = ~view_data["mask"]
         if invalid_mask.any():
-            # Create a light grey overlay (RGB: 192, 192, 192)
             overlay_color = np.array([255, 220, 220], dtype=np.uint8)
-
-            # Apply overlay with some transparency
-            alpha = 0.5  # Transparency level
-            for c in range(3):  # RGB channels
-                image[:, :, c] = np.where(
-                    invalid_mask,
-                    (1 - alpha) * image[:, :, c] + alpha * overlay_color[c],
-                    image[:, :, c],
-                ).astype(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)
     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:
+    if not processed_data:
         return "View 1", None
-
-    # Parse current view number
     try:
         current_view = int(current_selector_value.split()[1]) - 1
     except:
         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
+    new_view = (current_view + direction) % len(processed_data)
+    return f"View {new_view + 1}", update_depth_view(processed_data, new_view)
 
 
 def navigate_normal_view(processed_data, current_selector_value, direction):
-    """Navigate normal view (direction: -1 for previous, +1 for next)"""
-    if processed_data is None or len(processed_data) == 0:
+    if not processed_data:
         return "View 1", None
-
-    # Parse current view number
     try:
         current_view = int(current_selector_value.split()[1]) - 1
     except:
         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
+    new_view = (current_view + direction) % len(processed_data)
+    return f"View {new_view + 1}", update_normal_view(processed_data, new_view)
 
 
 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:
+    if not processed_data:
         return "View 1", None, []
-
-    # Parse current view number
     try:
         current_view = int(current_selector_value.split()[1]) - 1
     except:
         current_view = 0
-
-    num_views = len(processed_data)
-    new_view = (current_view + direction) % num_views
-
-    new_selector_value = f"View {new_view + 1}"
+    new_view = (current_view + direction) % len(processed_data)
     measure_image, measure_points = update_measure_view(processed_data, new_view)
-
-    return new_selector_value, measure_image, measure_points
+    return f"View {new_view + 1}", measure_image, measure_points
 
 
 def populate_visualization_tabs(processed_data):
-    """Populate the depth, normal, and measure tabs with processed data"""
-    if processed_data is None or len(processed_data) == 0:
+    if not processed_data:
         return None, None, None, []
-
-    # Use update functions to ensure confidence filtering is applied from the start
-    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], []
 
 
 # -------------------------------------------------------------------------
-# 2) Handle uploaded video/images --> produce target_dir + images
+# 2) Handle uploaded video/images
 # -------------------------------------------------------------------------
 def handle_uploads(unified_upload, s_time_interval=1.0):
-    """
-    Create a new 'target_dir' + 'images' subfolder, and place user-uploaded
-    images or extracted frames from video into it. Return (target_dir, image_paths).
-    """
     start_time = time.time()
     gc.collect()
     torch.cuda.empty_cache()
 
-    # Create a unique folder name
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
     target_dir = f"input_images_{timestamp}"
     target_dir_images = os.path.join(target_dir, "images")
-
-    # Clean up if somehow that folder already exists
     if os.path.exists(target_dir):
         shutil.rmtree(target_dir)
-    os.makedirs(target_dir)
     os.makedirs(target_dir_images)
 
     image_paths = []
+    video_extensions = [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv", ".webm", ".m4v", ".3gp"]
 
-    # --- Handle uploaded files (both images and videos) ---
     if unified_upload is not None:
         for file_data in unified_upload:
-            if isinstance(file_data, dict) and "name" in file_data:
-                file_path = file_data["name"]
-            else:
-                file_path = str(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()
 
-            # Check if it's a video file
-            video_extensions = [
-                ".mp4",
-                ".avi",
-                ".mov",
-                ".mkv",
-                ".wmv",
-                ".flv",
-                ".webm",
-                ".m4v",
-                ".3gp",
-            ]
             if file_ext in video_extensions:
-                # Handle as video
                 vs = cv2.VideoCapture(file_path)
                 fps = vs.get(cv2.CAP_PROP_FPS)
-                frame_interval = int(fps * s_time_interval)  # frames per interval
-
-                count = 0
-                video_frame_num = 0
+                frame_interval = int(fps * s_time_interval)
+                count, video_frame_num = 0, 0
                 while True:
                     gotit, frame = vs.read()
                     if not gotit:
                         break
                     count += 1
                     if count % frame_interval == 0:
-                        # Use original filename as prefix for frames
                         base_name = os.path.splitext(os.path.basename(file_path))[0]
-                        image_path = os.path.join(
-                            target_dir_images, f"{base_name}_{video_frame_num:06}.png"
-                        )
+                        image_path = os.path.join(target_dir_images, f"{base_name}_{video_frame_num:06}.png")
                         cv2.imwrite(image_path, frame)
                         image_paths.append(image_path)
                         video_frame_num += 1
                 vs.release()
-                print(
-                    f"Extracted {video_frame_num} frames from video: {os.path.basename(file_path)}"
-                )
-
-            else:
-                # Handle as image
-                # Check if the file is a HEIC image
-                if file_ext in [".heic", ".heif"]:
-                    # Convert HEIC to JPEG for better gallery compatibility
-                    try:
-                        with Image.open(file_path) as img:
-                            # Convert to RGB if necessary (HEIC can have different color modes)
-                            if img.mode not in ("RGB", "L"):
-                                img = img.convert("RGB")
-
-                            # Create JPEG filename
-                            base_name = os.path.splitext(os.path.basename(file_path))[0]
-                            dst_path = os.path.join(
-                                target_dir_images, f"{base_name}.jpg"
-                            )
-
-                            # Save as JPEG with high quality
-                            img.save(dst_path, "JPEG", quality=95)
-                            image_paths.append(dst_path)
-                            print(
-                                f"Converted HEIC to JPEG: {os.path.basename(file_path)} -> {os.path.basename(dst_path)}"
-                            )
-                    except Exception as e:
-                        print(f"Error converting HEIC file {file_path}: {e}")
-                        # Fall back to copying as is
-                        dst_path = os.path.join(
-                            target_dir_images, os.path.basename(file_path)
-                        )
-                        shutil.copy(file_path, dst_path)
+                print(f"Extracted {video_frame_num} frames from: {os.path.basename(file_path)}")
+            elif 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)
-                else:
-                    # Regular image files - copy as is
-                    dst_path = os.path.join(
-                        target_dir_images, os.path.basename(file_path)
-                    )
+                except Exception as e:
+                    print(f"Error converting HEIC {file_path}: {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)
+            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)
 
-    # Sort final images for gallery
     image_paths = sorted(image_paths)
-
-    end_time = time.time()
-    print(
-        f"Files processed to {target_dir_images}; took {end_time - start_time:.3f} seconds"
-    )
+    print(f"Files processed to {target_dir_images}; took {time.time() - start_time:.3f}s")
     return target_dir, image_paths
 
 
 # -------------------------------------------------------------------------
-# 3) Update gallery on upload
-# -------------------------------------------------------------------------
-def update_gallery_on_upload(input_video, input_images, s_time_interval=1.0):
-    """
-    Whenever user uploads or changes files, immediately handle them
-    and show in the gallery. Return (target_dir, image_paths).
-    If nothing is uploaded, returns "None" and empty list.
-    """
-    if not input_video and not input_images:
-        return None, None, None, None
-    target_dir, image_paths = handle_uploads(input_video, input_images, s_time_interval)
-    return (
-        None,
-        target_dir,
-        image_paths,
-        "Upload complete. Click 'Reconstruct' to begin 3D processing.",
-    )
-
-
-# -------------------------------------------------------------------------
-# 4) Reconstruction: uses the target_dir plus any viz parameters
+# 3) Reconstruction
 # -------------------------------------------------------------------------
 @spaces.GPU(duration=120)
-def gradio_demo(
-    target_dir,
-    frame_filter="All",
-    show_cam=True,
-    filter_black_bg=False,
-    filter_white_bg=False,
-    apply_mask=True,
-    show_mesh=True,
-):
-    """
-    Perform reconstruction using the already-created target_dir/images.
-    """
+def gradio_demo(target_dir, frame_filter="All", show_cam=True, filter_black_bg=False, filter_white_bg=False, apply_mask=True, show_mesh=True):
     if not os.path.isdir(target_dir) or target_dir == "None":
         return None, "No valid target directory found. Please upload first.", None, None
 
@@ -576,411 +393,172 @@ def gradio_demo(
     gc.collect()
     torch.cuda.empty_cache()
 
-    # Prepare frame_filter dropdown
     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 = [f"{i}: {filename}" for i, filename in enumerate(all_files)]
-    frame_filter_choices = ["All"] + all_files
+    all_files = sorted(os.listdir(target_dir_images)) if os.path.isdir(target_dir_images) else []
+    all_files_labeled = [f"{i}: {filename}" for i, filename in enumerate(all_files)]
+    frame_filter_choices = ["All"] + all_files_labeled
 
     print("Running MapAnything model...")
     with torch.no_grad():
         predictions, processed_data = run_model(target_dir, apply_mask)
 
-    # Save predictions
-    prediction_save_path = os.path.join(target_dir, "predictions.npz")
-    np.savez(prediction_save_path, **predictions)
+    np.savez(os.path.join(target_dir, "predictions.npz"), **predictions)
 
-    # Handle None frame_filter
     if frame_filter is None:
         frame_filter = "All"
 
-    # Build a GLB file name
     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",
     )
-
-    # Convert predictions to 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,  # Use the show_mesh parameter
-    )
+    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)
     glbscene.export(file_obj=glbfile)
-    
-    # ---------------------------------------------------------
-    # Generate the Rerun recording using the new helper
-    # ---------------------------------------------------------
-    rrd_path = create_rerun_recording(glbfile, target_dir)
 
-    # Cleanup
+    rrd_path = predictions_to_rrd(predictions, glbfile, target_dir, frame_filter, show_cam)
+
     del predictions
     gc.collect()
     torch.cuda.empty_cache()
 
-    end_time = time.time()
-    print(f"Total time: {end_time - start_time:.2f} seconds")
-    log_msg = (
-        f"Reconstruction Success ({len(all_files)} frames). Waiting for visualization."
-    )
-
-    # Populate visualization tabs with processed data
-    depth_vis, normal_vis, measure_img, measure_pts = populate_visualization_tabs(
-        processed_data
-    )
+    print(f"Total time: {time.time() - start_time:.2f}s")
+    log_msg = f"✅ Reconstruction complete — {len(all_files)} frames processed."
 
-    # Update view selectors based on available views
-    depth_selector, normal_selector, measure_selector = update_view_selectors(
-        processed_data
-    )
+    depth_vis, normal_vis, measure_img, measure_pts = populate_visualization_tabs(processed_data)
+    depth_selector, normal_selector, measure_selector = update_view_selectors(processed_data)
 
     return (
-        rrd_path, # Return the Rerun recording path instead of glbfile
-        log_msg,
+        rrd_path, log_msg,
         gr.Dropdown(choices=frame_filter_choices, value=frame_filter, interactive=True),
-        processed_data,
-        depth_vis,
-        normal_vis,
-        measure_img,
-        "",  # measure_text (empty initially)
-        depth_selector,
-        normal_selector,
-        measure_selector,
+        processed_data, depth_vis, normal_vis, measure_img, "",
+        depth_selector, normal_selector, measure_selector,
     )
 
 
 # -------------------------------------------------------------------------
-# 5) Helper functions for UI resets + re-visualization
+# 4) Helper / visualization functions
 # -------------------------------------------------------------------------
 def colorize_depth(depth_map, mask=None):
-    """Convert depth map to colorized visualization with optional mask"""
     if depth_map is None:
         return None
-
-    # Normalize depth to 0-1 range
     depth_normalized = depth_map.copy()
     valid_mask = depth_normalized > 0
-
-    # Apply additional mask if provided (for background filtering)
     if mask is not None:
         valid_mask = valid_mask & mask
-
     if valid_mask.sum() > 0:
         valid_depths = depth_normalized[valid_mask]
-        p5 = np.percentile(valid_depths, 5)
-        p95 = np.percentile(valid_depths, 95)
-
+        p5, p95 = np.percentile(valid_depths, 5), np.percentile(valid_depths, 95)
         depth_normalized[valid_mask] = (depth_normalized[valid_mask] - p5) / (p95 - p5)
-
-    # Apply colormap
     import matplotlib.pyplot as plt
-
-    colormap = plt.cm.turbo_r
-    colored = colormap(depth_normalized)
-    colored = (colored[:, :, :3] * 255).astype(np.uint8)
-
-    # Set invalid pixels to white
+    colored = (plt.cm.turbo_r(depth_normalized)[:, :, :3] * 255).astype(np.uint8)
     colored[~valid_mask] = [255, 255, 255]
-
     return colored
 
 
 def colorize_normal(normal_map, mask=None):
-    """Convert normal map to colorized visualization with optional mask"""
     if normal_map is None:
         return None
-
-    # Create a copy for modification
     normal_vis = normal_map.copy()
-
-    # Apply mask if provided (set masked areas to [0, 0, 0] which becomes grey after normalization)
     if mask is not None:
-        invalid_mask = ~mask
-        normal_vis[invalid_mask] = [0, 0, 0]  # Set invalid areas to zero
+        normal_vis[~mask] = [0, 0, 0]
+    return ((normal_vis + 1.0) / 2.0 * 255).astype(np.uint8)
 
-    # Normalize normals to [0, 1] range for visualization
-    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
-):
-    """Extract depth, normal, and 3D points from predictions for visualization"""
+def process_predictions_for_visualization(predictions, views, high_level_config, filter_black_bg=False, filter_white_bg=False):
     processed_data = {}
-
-    # Process each view
     for view_idx, view in enumerate(views):
-        # Get image
         image = rgb(view["img"], norm_type=high_level_config["data_norm_type"])
-
-        # Get predicted points
         pred_pts3d = predictions["world_points"][view_idx]
-
-        # Initialize data for this view
-        view_data = {
-            "image": image[0],
-            "points3d": pred_pts3d,
-            "depth": None,
-            "normal": None,
-            "mask": None,
-        }
-
-        # Start with the final mask from predictions
         mask = predictions["final_mask"][view_idx].copy()
-
-        # Apply black background filtering if enabled
         if filter_black_bg:
-            # Get the image colors (ensure they're in 0-255 range)
             view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
-            # Filter out black background pixels (sum of RGB < 16)
-            black_bg_mask = view_colors.sum(axis=2) >= 16
-            mask = mask & black_bg_mask
-
-        # Apply white background filtering if enabled
+            mask = mask & (view_colors.sum(axis=2) >= 16)
         if filter_white_bg:
-            # Get the image colors (ensure they're in 0-255 range)
             view_colors = image[0] * 255 if image[0].max() <= 1.0 else image[0]
-            # Filter out white background pixels (all RGB > 240)
-            white_bg_mask = ~(
-                (view_colors[:, :, 0] > 240)
-                & (view_colors[:, :, 1] > 240)
-                & (view_colors[:, :, 2] > 240)
-            )
-            mask = mask & white_bg_mask
-
-        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
-
+            mask = mask & ~((view_colors[:, :, 0] > 240) & (view_colors[:, :, 1] > 240) & (view_colors[:, :, 2] > 240))
+        normals, _ = points_to_normals(pred_pts3d, mask=mask)
+        processed_data[view_idx] = {
+            "image": image[0],
+            "points3d": pred_pts3d,
+            "depth": predictions["depth"][view_idx].squeeze(),
+            "normal": normals,
+            "mask": mask,
+        }
     return processed_data
 
 
-def reset_measure(processed_data):
-    """Reset measure points"""
-    if processed_data is None or len(processed_data) == 0:
-        return None, [], ""
-
-    # Return the first view image
-    first_view = list(processed_data.values())[0]
-    return first_view["image"], [], ""
-
-
-def measure(
-    processed_data, measure_points, current_view_selector, event: gr.SelectData
-):
-    """Handle measurement on images"""
+def measure(processed_data, measure_points, current_view_selector, event: gr.SelectData):
     try:
-        print(f"Measure function called with selector: {current_view_selector}")
-
-        if processed_data is None or len(processed_data) == 0:
+        if not processed_data:
             return None, [], "No data available"
-
-        # Use the currently selected view instead of always using the first view
         try:
             current_view_index = int(current_view_selector.split()[1]) - 1
         except:
             current_view_index = 0
-
-        print(f"Using view index: {current_view_index}")
-
-        # Get view data safely
-        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]]
-
+        current_view_index = max(0, min(current_view_index, len(processed_data) - 1))
+        current_view = processed_data[list(processed_data.keys())[current_view_index]]
         if current_view is None:
             return None, [], "No view data available"
 
         point2d = event.index[0], event.index[1]
-        print(f"Clicked point: {point2d}")
-
-        # Check if the clicked point is in a masked area (prevent interaction)
-        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]
-        ):
-            # Check if the point is in a masked (invalid) area
+        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]]:
-                print(f"Clicked point {point2d} is in masked area, ignoring click")
-                # Always return image with mask overlay
-                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>',
-                )
+                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</span>'
 
         measure_points.append(point2d)
-
-        # Get image with mask overlay and ensure it's valid
         image, _ = update_measure_view(processed_data, current_view_index)
         if image is None:
             return None, [], "No image available"
-
         image = image.copy()
+        if image.dtype != np.uint8:
+            image = (image * 255).astype(np.uint8) if image.max() <= 1.0 else image.astype(np.uint8)
         points3d = current_view["points3d"]
 
-        # Ensure image is in uint8 format for proper cv2 operations
-        try:
-            if image.dtype != np.uint8:
-                if image.max() <= 1.0:
-                    # Image is in [0, 1] range, convert to [0, 255]
-                    image = (image * 255).astype(np.uint8)
-                else:
-                    # Image is already in [0, 255] range
-                    image = image.astype(np.uint8)
-        except Exception as e:
-            print(f"Image conversion error: {e}")
-            return None, [], f"Image conversion error: {e}"
-
-        # Draw circles for points
-        try:
-            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
-                    )
-        except Exception as e:
-            print(f"Drawing error: {e}")
-            return None, [], f"Drawing error: {e}"
+        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)
 
         depth_text = ""
-        try:
-            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]
-                ):
-                    d = current_view["depth"][p[1], p[0]]
-                    depth_text += f"- **P{i + 1} depth: {d:.2f}m.**\n"
-                else:
-                    # Use Z coordinate of 3D points if depth not available
-                    if (
-                        points3d is not None
-                        and 0 <= p[1] < points3d.shape[0]
-                        and 0 <= p[0] < points3d.shape[1]
-                    ):
-                        z = points3d[p[1], p[0], 2]
-                        depth_text += f"- **P{i + 1} Z-coord: {z:.2f}m.**\n"
-        except Exception as e:
-            print(f"Depth text error: {e}")
-            depth_text = f"Error computing depth: {e}\n"
+        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"
+            elif points3d is not None and 0 <= p[1] < points3d.shape[0] and 0 <= p[0] < points3d.shape[1]:
+                depth_text += f"- **P{i + 1} Z-coord: {points3d[p[1], p[0], 2]:.2f}m**\n"
 
         if len(measure_points) == 2:
-            try:
-                point1, point2 = measure_points
-                # Draw line
-                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]
-                ):
-                    image = cv2.line(
-                        image, point1, point2, color=(255, 0, 0), thickness=2
-                    )
-
-                # Compute 3D 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]
-                ):
-                    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:
-                        print(f"Distance computation error: {e}")
-                        distance_text = f"- **Distance computation error: {e}**"
-
-                measure_points = []
-                text = depth_text + distance_text
-                print(f"Measurement complete: {text}")
-                return [image, measure_points, text]
-            except Exception as e:
-                print(f"Final measurement error: {e}")
-                return None, [], f"Measurement error: {e}"
-        else:
-            print(f"Single point measurement: {depth_text}")
-            return [image, measure_points, depth_text]
-
+            point1, point2 = measure_points
+            if all(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] for _ in [1]):
+                image = cv2.line(image, point1, point2, color=(255, 0, 0), thickness=2)
+            distance_text = "- **Distance: Unable to compute**"
+            if points3d is not None and all(0 <= p[1] < points3d.shape[0] and 0 <= p[0] < points3d.shape[1] for p in [point1, point2]):
+                try:
+                    distance = np.linalg.norm(points3d[point1[1], point1[0]] - points3d[point2[1], point2[0]])
+                    distance_text = f"- **Distance: {distance:.2f}m**"
+                except Exception as e:
+                    distance_text = f"- **Distance error: {e}**"
+            return [image, [], depth_text + distance_text]
+        return [image, measure_points, depth_text]
     except Exception as e:
-        print(f"Overall measure function error: {e}")
-        return None, [], f"Measure function error: {e}"
+        print(f"Measure error: {e}")
+        return None, [], f"Error: {e}"
 
 
 def clear_fields():
-    """
-    Clears the 3D viewer, the stored target_dir, and empties the gallery.
-    """
     return None
 
 
 def update_log():
-    """
-    Display a quick log message while waiting.
-    """
-    return "Loading and Reconstructing..."
-
-
-def update_visualization(
-    target_dir,
-    frame_filter,
-    show_cam,
-    is_example,
-    filter_black_bg=False,
-    filter_white_bg=False,
-    show_mesh=True,
-):
-    """
-    Reload saved predictions from npz, create (or reuse) the GLB for new parameters,
-    wrap it in a Rerun recording (.rrd), and return it for the Rerun viewer.
-    """
-
-    # If it's an example click, skip as requested
-    if is_example == "True":
-        return (
-            gr.update(),
-            "No reconstruction available. Please click the Reconstruct button first.",
-        )
+    return "⏳ Loading and reconstructing…"
 
-    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.",
-        )
 
+def update_visualization(target_dir, frame_filter, show_cam, is_example, filter_black_bg=False, filter_white_bg=False, show_mesh=True):
+    if is_example == "True":
+        return gr.update(), "No reconstruction available. Please click Reconstruct first."
+    if not target_dir or target_dir == "None" or not os.path.isdir(target_dir):
+        return gr.update(), "No reconstruction available. Please upload first."
     predictions_path = os.path.join(target_dir, "predictions.npz")
     if not os.path.exists(predictions_path):
-        return (
-            gr.update(),
-            f"No reconstruction available at {predictions_path}. Please run 'Reconstruct' first.",
-        )
+        return gr.update(), "No reconstruction found. Please run Reconstruct first."
 
     loaded = np.load(predictions_path, allow_pickle=True)
     predictions = {key: loaded[key] for key in loaded.keys()}
@@ -989,95 +567,36 @@ def update_visualization(
         target_dir,
         f"glbscene_{frame_filter.replace('.', '_').replace(':', '').replace(' ', '_')}_cam{show_cam}_mesh{show_mesh}_black{filter_black_bg}_white{filter_white_bg}.glb",
     )
-
     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,
-        )
+        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)
         glbscene.export(file_obj=glbfile)
-        
-    # Generate the Rerun recording using the helper
-    rrd_path = create_rerun_recording(glbfile, target_dir)
 
-    return (
-        rrd_path,  # Was glbfile
-        "Visualization updated.",
-    )
+    rrd_path = predictions_to_rrd(predictions, glbfile, target_dir, frame_filter, show_cam)
+    return rrd_path, "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,
-):
-    """
-    Update all individual view tabs when background filtering checkboxes change.
-    This regenerates the processed data with new filtering and updates all views.
-    """
-    # Check if we have a valid target directory and predictions
+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):
     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):
         return processed_data, None, None, None, []
-
     try:
-        # Load the original predictions and views
         loaded = np.load(predictions_path, allow_pickle=True)
         predictions = {key: loaded[key] for key in loaded.keys()}
-
-        # Load images using MapAnything's load_images function
-        image_folder_path = os.path.join(target_dir, "images")
-        views = load_images(image_folder_path)
-
-        # Regenerate processed data with new filtering settings
-        new_processed_data = process_predictions_for_visualization(
-            predictions, views, high_level_config, filter_black_bg, filter_white_bg
-        )
-
-        # Get current view indices
-        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
-
-        # Update all views with new filtered data
-        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)
-
+        views = load_images(os.path.join(target_dir, "images"))
+        new_processed_data = process_predictions_for_visualization(predictions, views, high_level_config, filter_black_bg, filter_white_bg)
+        def safe_idx(sel):
+            try:
+                return int(sel.split()[1]) - 1
+            except:
+                return 0
+        depth_vis = update_depth_view(new_processed_data, safe_idx(depth_view_selector))
+        normal_vis = update_normal_view(new_processed_data, safe_idx(normal_view_selector))
+        measure_img, _ = update_measure_view(new_processed_data, safe_idx(measure_view_selector))
         return new_processed_data, depth_vis, normal_vis, measure_img, []
-
     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, []
 
 
@@ -1085,446 +604,469 @@ def update_all_views_on_filter_change(
 # Example scene functions
 # -------------------------------------------------------------------------
 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):
-            # Find all image files in the scene folder
-            image_extensions = ["*.jpg", "*.jpeg", "*.png", "*.bmp", "*.tiff", "*.tif"]
             image_files = []
-            for ext in image_extensions:
+            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:
-                # Sort images and get the first one for thumbnail
                 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,
-                    }
-                )
-
+                scenes.append({"name": scene_folder, "path": scene_path, "thumbnail": image_files[0], "num_images": len(image_files), "image_files": image_files})
     return scenes
 
 
 def load_example_scene(scene_name, examples_dir="examples"):
-    """Load a scene from examples directory"""
     scenes = get_scene_info(examples_dir)
-
-    # Find the selected scene
-    selected_scene = None
-    for scene in scenes:
-        if scene["name"] == scene_name:
-            selected_scene = scene
-            break
-
+    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"
+    target_dir, image_paths = handle_uploads(selected_scene["image_files"], 1.0)
+    return None, target_dir, image_paths, f"Loaded '{scene_name}' — {selected_scene['num_images']} images. Click Reconstruct."
+
 
-    # Create file-like objects for the unified upload system
-    # Convert image file paths to the format expected by unified_upload
-    file_objects = []
-    for image_path in selected_scene["image_files"]:
-        file_objects.append(image_path)
+# -------------------------------------------------------------------------
+# CSS
+# -------------------------------------------------------------------------
+CUSTOM_CSS = (GRADIO_CSS or "") + """
+/* ── Page shell ── */
+#app-shell {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 0 16px 40px;
+}
 
-    # Create target directory and copy images using the unified upload system
-    target_dir, image_paths = handle_uploads(file_objects, 1.0)
+/* ── Header ── */
+#app-header {
+    padding: 28px 0 20px;
+    border-bottom: 1px solid var(--border-color-primary);
+    margin-bottom: 24px;
+}
+#app-header h1 {
+    font-size: 2rem !important;
+    font-weight: 700 !important;
+    margin: 0 0 4px !important;
+    line-height: 1.2 !important;
+}
+#app-header p {
+    margin: 0 !important;
+    opacity: 0.65;
+    font-size: 0.95rem !important;
+}
 
-    return (
-        None,  # Clear reconstruction output
-        target_dir,  # Set target directory
-        image_paths,  # Set gallery
-        f"Loaded scene '{scene_name}' with {selected_scene['num_images']} images. Click 'Reconstruct' to begin 3D processing.",
-    )
+/* ── Two-panel layout ── */
+#left-panel  { min-width: 320px; max-width: 380px; }
+#right-panel { flex: 1; min-width: 0; }
+
+/* ── Section labels ── */
+.section-label {
+    font-size: 0.7rem !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.08em !important;
+    text-transform: uppercase !important;
+    opacity: 0.5 !important;
+    margin-bottom: 6px !important;
+    margin-top: 16px !important;
+    display: block !important;
+}
 
+/* ── Upload zone ── */
+#upload-zone .wrap {
+    border-radius: 10px !important;
+    min-height: 110px !important;
+}
+
+/* ── Gallery ── */
+#preview-gallery { border-radius: 10px; overflow: hidden; }
+
+/* ── Action buttons ── */
+#btn-reconstruct {
+    width: 100% !important;
+    font-size: 0.95rem !important;
+    font-weight: 600 !important;
+    padding: 12px !important;
+    border-radius: 8px !important;
+}
+
+/* ── Log strip ── */
+#log-strip {
+    font-size: 0.82rem !important;
+    padding: 8px 12px !important;
+    border-radius: 6px !important;
+    border: 1px solid var(--border-color-primary) !important;
+    background: var(--background-fill-secondary) !important;
+    min-height: 36px !important;
+}
+
+/* ── Viewer tabs ── */
+#viewer-tabs .tab-nav button {
+    font-size: 0.8rem !important;
+    font-weight: 500 !important;
+    padding: 6px 14px !important;
+}
+#viewer-tabs > .tabitem { padding: 0 !important; }
+
+/* ── Navigation rows inside tabs ── */
+.nav-row { align-items: center !important; gap: 6px !important; margin-bottom: 8px !important; }
+.nav-row button { min-width: 80px !important; }
+
+/* ── Options panel ── */
+#options-panel {
+    border: 1px solid var(--border-color-primary);
+    border-radius: 10px;
+    padding: 16px;
+    margin-top: 12px;
+}
+#options-panel .gr-markdown h3 {
+    font-size: 0.72rem !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.07em !important;
+    text-transform: uppercase !important;
+    opacity: 0.5 !important;
+    margin: 14px 0 6px !important;
+}
+#options-panel .gr-markdown h3:first-child { margin-top: 0 !important; }
+
+/* ── Frame filter ── */
+#frame-filter { margin-top: 12px; }
+
+/* ── Examples section ── */
+#examples-section { margin-top: 36px; padding-top: 24px; border-top: 1px solid var(--border-color-primary); }
+#examples-section h2 { font-size: 1.1rem !important; font-weight: 600 !important; margin-bottom: 4px !important; }
+#examples-section .scene-caption {
+    font-size: 0.75rem !important;
+    text-align: center !important;
+    opacity: 0.65 !important;
+    margin-top: 4px !important;
+}
+.scene-thumb img { border-radius: 8px; transition: opacity .15s; }
+.scene-thumb img:hover { opacity: .85; }
+
+/* ── Measure note ── */
+.measure-note { font-size: 0.78rem !important; opacity: 0.6 !important; margin-top: 6px !important; }
+"""
 
 # -------------------------------------------------------------------------
 # 6) Build Gradio UI
 # -------------------------------------------------------------------------
-theme = get_gradio_theme()
-
-with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
-    # State variables
-    is_example = gr.Textbox(label="is_example", visible=False, value="None")
-    num_images = gr.Textbox(label="num_images", visible=False, value="None")
-    processed_data_state = gr.State(value=None)
-    measure_points_state = gr.State(value=[])
-    current_view_index = gr.State(value=0)  
-    target_dir_output = gr.Textbox(label="Target Dir", visible=False, value="None")
-
-    # --- Header Area ---
-    with gr.Column(elem_id="header-container"):
-        gr.Markdown(
-            "<div style='text-align: center; max-width: 800px; margin: 0 auto; padding-top: 10px;'>"
-            "<h1>🗺️ Map-Anything-v1</h1>"
-            "<h3 style='color: #666; font-weight: 400;'>Metric 3D Reconstruction (Point Cloud and Camera Poses)</h3>"
-            "</div>"
-        )
-        gr.Markdown("---")
-
-    # --- Main App Layout ---
-    with gr.Row():
-        
-        # LEFT COLUMN (Sidebar / Controls)
-        with gr.Column(scale=1, min_width=350):
-            
-            with gr.Group():
-                gr.Markdown("### 📁 1. Input Media")
+with gr.Blocks(css=CUSTOM_CSS) as demo:
+
+    # Hidden state
+    is_example            = gr.Textbox(visible=False, value="None")
+    num_images            = gr.Textbox(visible=False, value="None")
+    processed_data_state  = gr.State(value=None)
+    measure_points_state  = gr.State(value=[])
+    target_dir_output     = gr.Textbox(visible=False, value="None")
+
+    # ── Header ──────────────────────────────────────────────────────────
+    with gr.Column(elem_id="app-shell"):
+        with gr.Column(elem_id="app-header"):
+            gr.Markdown("# **Map-Anything-v1**")
+            gr.Markdown("Metric 3D Reconstruction (Point Cloud and Camera Poses)")
+
+        # ── Main two-column layout ───────────────────────────────────────
+        with gr.Row(equal_height=False):
+
+            # ── LEFT PANEL ─────────────────────────────────────────────
+            with gr.Column(elem_id="left-panel", scale=0):
+
+                gr.Markdown('<span class="section-label">Input</span>')
                 unified_upload = gr.File(
                     file_count="multiple",
                     label="Upload Video or Images",
-                    interactive=True,
                     file_types=["image", "video"],
+                    elem_id="upload-zone",
                 )
+
                 with gr.Row():
                     s_time_interval = gr.Slider(
-                        minimum=0.1,
-                        maximum=5.0,
-                        value=1.0,
-                        step=0.1,
+                        minimum=0.1, maximum=5.0, value=1.0, step=0.1,
                         label="Video sample interval (sec)",
-                        interactive=True,
-                        visible=True,
+                        scale=3,
                     )
-                    resample_btn = gr.Button("Resample", visible=False, variant="secondary")
+                    resample_btn = gr.Button("Resample", visible=False, variant="secondary", scale=1)
 
+                gr.Markdown('<span class="section-label">Preview</span>')
                 image_gallery = gr.Gallery(
-                    label="Preview",
-                    columns=4,
-                    height="200px",
-                    object_fit="contain",
+                    label="",
+                    columns=3,
+                    height="220px",
+                    object_fit="cover",
                     preview=True,
+                    elem_id="preview-gallery",
+                    show_label=False,
                 )
-                clear_uploads_btn = gr.ClearButton(
+
+                gr.ClearButton(
                     [unified_upload, image_gallery],
-                    value="Clear Uploads",
+                    value="Clear uploads",
                     variant="secondary",
                     size="sm",
                 )
 
-            with gr.Group():
-                gr.Markdown("### ⚙️ 2. Reconstruction Settings")
-                apply_mask_checkbox = gr.Checkbox(
-                    label="Apply mask (depth classes & edges)",
-                    value=True,
-                )
-                
-                with gr.Row():
-                    submit_btn = gr.Button("🚀 Reconstruct", variant="primary", scale=2)
-                    clear_btn = gr.ClearButton(
-                        [
-                            unified_upload,
-                            target_dir_output,
-                            image_gallery,
-                        ],
-                        value="Clear All",
-                        scale=1,
+                gr.Markdown('<span class="section-label">Run</span>')
+                submit_btn = gr.Button("Reconstruct", variant="primary", elem_id="btn-reconstruct")
+
+                # Options accordion
+                with gr.Accordion("Options", open=False, elem_id="options-panel"):
+                    gr.Markdown("### Point Cloud")
+                    show_cam      = gr.Checkbox(label="Show cameras", 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)
+                    gr.Markdown("### Reconstruction (next run)")
+                    apply_mask_checkbox = gr.Checkbox(
+                        label="Apply ambiguous-depth mask & edges", value=True
                     )
 
-            with gr.Accordion("🎨 Visualization Options", open=True):
-                gr.Markdown("*Note: Updates automatically applied to viewer.*")
+                gr.Markdown('<span class="section-label">Filter by frame</span>')
                 frame_filter = gr.Dropdown(
-                    choices=["All"], value="All", label="Show Points from Frame"
+                    choices=["All"], value="All", label="",
+                    elem_id="frame-filter", show_label=False,
                 )
-                show_cam = gr.Checkbox(label="Show Camera Paths", value=True)
-                show_mesh = gr.Checkbox(label="Show 3D 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)
-
-
-        # RIGHT COLUMN (Main Viewer Area)
-        with gr.Column(scale=2, min_width=600):
-            log_output = gr.Markdown("Status: **Ready**. Please upload media or select an example scene below.", elem_classes=["custom-log"])
-            
-            with gr.Tabs():
-                with gr.Tab("3D View"):
-                    reconstruction_output = Rerun(
-                        label="Rerun 3D Viewer",
-                        height=600,
-                    )
-                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,
-                            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,
-                    )
-                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,
-                            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,
-                    )
-                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,
-                            allow_custom_value=True,
+
+            # ── RIGHT PANEL ────────────────────────────────────────────
+            with gr.Column(elem_id="right-panel", scale=1):
+
+                # Status log
+                log_output = gr.Markdown(
+                    "Upload a video or images, then click **Reconstruct**.",
+                    elem_id="log-strip",
+                )
+
+                # Viewer tabs
+                with gr.Tabs(elem_id="viewer-tabs"):
+
+                    # 3-D View
+                    with gr.Tab("3D View"):
+                        reconstruction_output = Rerun(
+                            label="Rerun 3D Viewer",
+                            height=560,
                         )
-                        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 indicate regions with no depth information where measurements cannot be taken.")
-                    measure_text = gr.Markdown("")
-
-    # --- Footer Area (Example Scenes) ---
-    gr.Markdown("---")
-    gr.Markdown("## 🌟 Example Scenes")
-    gr.Markdown("Click any thumbnail below to load a sample dataset for reconstruction.")
-
-    scenes = get_scene_info("examples")
-
-    if scenes:
-        for i in range(0, len(scenes), 4):  
-            with gr.Row():
-                for j in range(4):
-                    scene_idx = i + j
-                    if scene_idx < len(scenes):
-                        scene = scenes[scene_idx]
-                        with gr.Column(scale=1, elem_classes=["clickable-thumbnail"]):
-                            scene_img = gr.Image(
-                                value=scene["thumbnail"],
-                                height=150,
-                                interactive=False,
-                                show_label=False,
-                                elem_id=f"scene_thumb_{scene['name']}",
-                                sources=[],
+
+                    # Depth
+                    with gr.Tab("Depth"):
+                        with gr.Row(elem_classes=["nav-row"]):
+                            prev_depth_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                            depth_view_selector = gr.Dropdown(
+                                choices=["View 1"], value="View 1",
+                                label="View", scale=3, interactive=True,
+                                allow_custom_value=True, show_label=False,
                             )
-                            gr.Markdown(
-                                f"**{scene['name']}** \n {scene['num_images']} images",
-                                elem_classes=["scene-info"],
+                            next_depth_btn = gr.Button("Next ▶", size="sm", scale=1)
+                        depth_map = gr.Image(
+                            type="numpy", label="Depth Map",
+                            format="png", interactive=False,
+                        )
+
+                    # Normal
+                    with gr.Tab("Normal"):
+                        with gr.Row(elem_classes=["nav-row"]):
+                            prev_normal_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                            normal_view_selector = gr.Dropdown(
+                                choices=["View 1"], value="View 1",
+                                label="View", scale=3, interactive=True,
+                                allow_custom_value=True, show_label=False,
                             )
-                            # Clicking an example bypasses the manual process and loads everything automatically
-                            scene_img.select(
-                                fn=lambda name=scene["name"]: load_example_scene(name),
-                                outputs=[
-                                    reconstruction_output, # To clear old view
-                                    target_dir_output,
-                                    image_gallery,
-                                    log_output,
-                                ],
+                            next_normal_btn = gr.Button("Next ▶", size="sm", scale=1)
+                        normal_map = gr.Image(
+                            type="numpy", label="Normal Map",
+                            format="png", interactive=False,
+                        )
+
+                    # Measure
+                    with gr.Tab("Measure"):
+                        gr.Markdown(MEASURE_INSTRUCTIONS_HTML)
+                        with gr.Row(elem_classes=["nav-row"]):
+                            prev_measure_btn = gr.Button("◀ Prev", size="sm", scale=1)
+                            measure_view_selector = gr.Dropdown(
+                                choices=["View 1"], value="View 1",
+                                label="View", scale=3, interactive=True,
+                                allow_custom_value=True, show_label=False,
                             )
-                    else:
-                        with gr.Column(scale=1):
-                            pass
+                            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(
+                            "Light-grey areas have no depth — measurements cannot be placed there.",
+                            elem_classes=["measure-note"],
+                        )
+                        measure_text = gr.Markdown("")
+
+        # ── Examples ────────────────────────────────────────────────────
+        with gr.Column(elem_id="examples-section"):
+            gr.Markdown("## Example Scenes")
+            gr.Markdown("Click a thumbnail to load the scene, then press **Reconstruct**.")
+
+            scenes = get_scene_info("examples")
+            if scenes:
+                for i in range(0, len(scenes), 4):
+                    with gr.Row():
+                        for j in range(4):
+                            idx = i + j
+                            if idx < len(scenes):
+                                scene = scenes[idx]
+                                with gr.Column(scale=1, min_width=140, elem_classes=["scene-thumb"]):
+                                    scene_img = gr.Image(
+                                        value=scene["thumbnail"],
+                                        height=130,
+                                        interactive=False,
+                                        show_label=False,
+                                        sources=[],
+                                    )
+                                    gr.Markdown(
+                                        f"**{scene['name']}**  \n{scene['num_images']} imgs",
+                                        elem_classes=["scene-caption"],
+                                    )
+                                    scene_img.select(
+                                        fn=lambda name=scene["name"]: load_example_scene(name),
+                                        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+                                    )
+                            else:
+                                with gr.Column(scale=1, min_width=140):
+                                    pass
 
     # =========================================================================
-    # Event Bindings & Logic
+    # Event wiring
     # =========================================================================
 
-    submit_btn.click(fn=clear_fields, inputs=[], outputs=[reconstruction_output]).then(
+    # Reconstruct button
+    submit_btn.click(
+        fn=clear_fields, inputs=[], outputs=[reconstruction_output]
+    ).then(
         fn=update_log, inputs=[], outputs=[log_output]
     ).then(
         fn=gradio_demo,
-        inputs=[
-            target_dir_output,
-            frame_filter,
-            show_cam,
-            filter_black_bg,
-            filter_white_bg,
-            apply_mask_checkbox,
-            show_mesh,
-        ],
+        inputs=[target_dir_output, frame_filter, show_cam, filter_black_bg, filter_white_bg, apply_mask_checkbox, show_mesh],
         outputs=[
-            reconstruction_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,
+            reconstruction_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",
-        inputs=[],
-        outputs=[is_example], 
-    )
+    ).then(fn=lambda: "False", inputs=[], outputs=[is_example])
+
+    # Live visualization option updates
+    for trigger_inputs, trigger in [
+        ([target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg, show_mesh], frame_filter.change),
+        ([target_dir_output, frame_filter, show_cam, is_example], show_cam.change),
+        ([target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg, show_mesh], show_mesh.change),
+    ]:
+        trigger(update_visualization, trigger_inputs, [reconstruction_output, log_output])
 
-    # Real-time Visualization Updates
-    frame_filter.change(
-        update_visualization,
-        [target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg, show_mesh],
-        [reconstruction_output, log_output],
-    )
-    show_cam.change(
-        update_visualization,
-        [target_dir_output, frame_filter, show_cam, is_example],
-        [reconstruction_output, log_output],
-    )
     filter_black_bg.change(
         update_visualization,
         [target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg],
         [reconstruction_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],
+        update_all_views_on_filter_change,
+        [target_dir_output, filter_black_bg, filter_white_bg, processed_data_state, depth_view_selector, normal_view_selector, measure_view_selector],
+        [processed_data_state, depth_map, normal_map, measure_image, measure_points_state],
     )
     filter_white_bg.change(
         update_visualization,
         [target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg, show_mesh],
         [reconstruction_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],
-    )
-    show_mesh.change(
-        update_visualization,
-        [target_dir_output, frame_filter, show_cam, is_example, filter_black_bg, filter_white_bg, show_mesh],
-        [reconstruction_output, log_output],
+        update_all_views_on_filter_change,
+        [target_dir_output, filter_black_bg, filter_white_bg, processed_data_state, depth_view_selector, normal_view_selector, measure_view_selector],
+        [processed_data_state, depth_map, normal_map, measure_image, measure_points_state],
     )
 
-    # Auto-update gallery on upload
+    # Upload handling
     def update_gallery_on_unified_upload(files, interval):
         if not files:
-            return None, None, "Ready for upload."
+            return None, None, None
         target_dir, image_paths = handle_uploads(files, interval)
-        return target_dir, image_paths, "Upload complete. Click '🚀 Reconstruct' to begin 3D processing."
+        return target_dir, image_paths, "Upload complete. Click **Reconstruct** to begin."
 
     def show_resample_button(files):
-        if not files: return gr.update(visible=False)
+        if not files:
+            return gr.update(visible=False)
         video_exts = [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv", ".webm", ".m4v", ".3gp"]
-        has_video = False
-        for f_data in files:
-            f_path = str(f_data["name"] if isinstance(f_data, dict) else f_data)
-            if os.path.splitext(f_path)[1].lower() in video_exts:
-                has_video = True
-                break
+        has_video = any(os.path.splitext(str(f["name"] if isinstance(f, dict) else f))[1].lower() in video_exts for f in files)
         return gr.update(visible=has_video)
 
     def resample_video_with_new_interval(files, new_interval, current_target_dir):
-        if not files: return current_target_dir, None, "No files to resample.", gr.update(visible=False)
+        if not files:
+            return current_target_dir, None, "No files to resample.", gr.update(visible=False)
         video_exts = [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv", ".webm", ".m4v", ".3gp"]
-        has_video = any(os.path.splitext(str(f["name"] if isinstance(f, dict) else f))[1].lower() in video_exts for f in files)
-        
-        if not has_video: return current_target_dir, None, "No videos found.", gr.update(visible=False)
-        
+        if not any(os.path.splitext(str(f["name"] if isinstance(f, dict) else f))[1].lower() in video_exts for f in files):
+            return current_target_dir, None, "No videos found.", gr.update(visible=False)
         if current_target_dir and current_target_dir != "None" and os.path.exists(current_target_dir):
             shutil.rmtree(current_target_dir)
-
         target_dir, image_paths = handle_uploads(files, new_interval)
-        return target_dir, image_paths, f"Video resampled ({new_interval}s interval). Click '🚀 Reconstruct'.", gr.update(visible=False)
+        return target_dir, image_paths, f"Resampled at {new_interval}s. Click **Reconstruct**.", gr.update(visible=False)
 
     unified_upload.change(
         fn=update_gallery_on_unified_upload,
         inputs=[unified_upload, s_time_interval],
         outputs=[target_dir_output, image_gallery, log_output],
-    ).then(
-        fn=show_resample_button,
-        inputs=[unified_upload],
-        outputs=[resample_btn],
-    )
-
-    s_time_interval.change(
-        fn=show_resample_button,
-        inputs=[unified_upload],
-        outputs=[resample_btn],
-    )
+    ).then(fn=show_resample_button, inputs=[unified_upload], outputs=[resample_btn])
 
+    s_time_interval.change(fn=show_resample_button, inputs=[unified_upload], outputs=[resample_btn])
     resample_btn.click(
         fn=resample_video_with_new_interval,
         inputs=[unified_upload, s_time_interval, target_dir_output],
         outputs=[target_dir_output, image_gallery, log_output, resample_btn],
     )
 
-    # Measure Interactions
+    # Measure tab
     measure_image.select(
         fn=measure,
         inputs=[processed_data_state, measure_points_state, measure_view_selector],
         outputs=[measure_image, measure_points_state, measure_text],
     )
 
-    # Tab Navigations
+    # Depth tab navigation
     prev_depth_btn.click(
-        fn=lambda d, s: navigate_depth_view(d, s, -1),
+        fn=lambda pd, sel: navigate_depth_view(pd, sel, -1),
         inputs=[processed_data_state, depth_view_selector], outputs=[depth_view_selector, depth_map],
     )
     next_depth_btn.click(
-        fn=lambda d, s: navigate_depth_view(d, s, 1),
+        fn=lambda pd, sel: navigate_depth_view(pd, sel, 1),
         inputs=[processed_data_state, depth_view_selector], outputs=[depth_view_selector, depth_map],
     )
     depth_view_selector.change(
-        fn=lambda d, s: update_depth_view(d, int(s.split()[1]) - 1) if s else None,
+        fn=lambda pd, sel: update_depth_view(pd, int(sel.split()[1]) - 1) if sel else None,
         inputs=[processed_data_state, depth_view_selector], outputs=[depth_map],
     )
 
+    # Normal tab navigation
     prev_normal_btn.click(
-        fn=lambda d, s: navigate_normal_view(d, s, -1),
+        fn=lambda pd, sel: navigate_normal_view(pd, sel, -1),
         inputs=[processed_data_state, normal_view_selector], outputs=[normal_view_selector, normal_map],
     )
     next_normal_btn.click(
-        fn=lambda d, s: navigate_normal_view(d, s, 1),
+        fn=lambda pd, sel: navigate_normal_view(pd, sel, 1),
         inputs=[processed_data_state, normal_view_selector], outputs=[normal_view_selector, normal_map],
     )
     normal_view_selector.change(
-        fn=lambda d, s: update_normal_view(d, int(s.split()[1]) - 1) if s else None,
+        fn=lambda pd, sel: update_normal_view(pd, int(sel.split()[1]) - 1) if sel else None,
         inputs=[processed_data_state, normal_view_selector], outputs=[normal_map],
     )
 
+    # Measure tab navigation
     prev_measure_btn.click(
-        fn=lambda d, s: navigate_measure_view(d, s, -1),
-        inputs=[processed_data_state, measure_view_selector], outputs=[measure_view_selector, measure_image, measure_points_state],
+        fn=lambda pd, sel: navigate_measure_view(pd, sel, -1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
     )
     next_measure_btn.click(
-        fn=lambda d, s: navigate_measure_view(d, s, 1),
-        inputs=[processed_data_state, measure_view_selector], outputs=[measure_view_selector, measure_image, measure_points_state],
+        fn=lambda pd, sel: navigate_measure_view(pd, sel, 1),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_view_selector, measure_image, measure_points_state],
     )
     measure_view_selector.change(
-        fn=lambda d, s: update_measure_view(d, int(s.split()[1]) - 1) if s else (None, []),
-        inputs=[processed_data_state, measure_view_selector], outputs=[measure_image, measure_points_state],
+        fn=lambda pd, sel: update_measure_view(pd, int(sel.split()[1]) - 1) if sel else (None, []),
+        inputs=[processed_data_state, measure_view_selector],
+        outputs=[measure_image, measure_points_state],
     )
 
-    demo.queue(max_size=20).launch(theme=theme, css=GRADIO_CSS, show_error=True, share=True, ssr_mode=False)
+    demo.queue(max_size=20).launch(css=CUSTOM_CSS, show_error=True, share=True, ssr_mode=False)