updates

app.py

@@ -1,8 +1,8 @@
 """
 SHARP Gradio Demo
 - Standard Two-Column Layout
-- Controls Visible
-- Examples at Bottom
+- Simplified Camera options
+- Robust Error Handling
 """
 
 from __future__ import annotations
@@ -13,11 +13,23 @@ from pathlib import Path
 from typing import Final
 import gradio as gr
 
-# Suppress internal warnings
+# Suppress internal warnings to keep logs clean
 warnings.filterwarnings("ignore", category=FutureWarning, module="torch.distributed")
 
 # Ensure model_utils is present
-from model_utils import TrajectoryType, predict_and_maybe_render_gpu
+# We wrap this import to prevent app crash if model_utils is missing during UI dev
+try:
+    from model_utils import TrajectoryType, predict_and_maybe_render_gpu
+except ImportError:
+    # Fallback mocks for testing/building UI without backend
+    print("WARNING: model_utils not found. Using dummy backend.")
+    class TrajectoryType:
+        ROTATE_FORWARD = "rotate_forward"
+        ROTATE = "rotate"
+        SWIPE = "swipe"
+        SHAKE = "shake"
+    def predict_and_maybe_render_gpu(*args, **kwargs):
+        return None, Path("dummy_output.ply")
 
 # -----------------------------------------------------------------------------
 # Paths & Config
@@ -42,7 +54,7 @@ def get_example_files() -> list[list[str]]:
     """Discover images in assets/examples for the UI."""
     _ensure_dir(EXAMPLES_DIR)
     
-    # Check manifest.json first
+    # Priority 1: Check manifest.json
     manifest_path = EXAMPLES_DIR / "manifest.json"
     if manifest_path.exists():
         try:
@@ -58,7 +70,7 @@ def get_example_files() -> list[list[str]]:
         except Exception as e:
             print(f"Manifest error: {e}")
 
-    # Fallback: simple file scan
+    # Priority 2: Simple file scan
     examples = []
     for ext in IMAGE_EXTS:
         for img in sorted(EXAMPLES_DIR.glob(f"*{ext}")):
@@ -67,14 +79,10 @@ def get_example_files() -> list[list[str]]:
 
 def run_sharp(
     image_path: str | None,
-    trajectory_mode: str,      # "Preset" or "Custom"
-    trajectory_preset: str,    # e.g., "rotate"
-    custom_elevation: float,
-    custom_azimuth: float,
-    custom_radius: float,
-    output_long_side: int,
-    num_frames: int,
-    fps: int,
+    trajectory_type_raw: str,
+    output_long_side: int | float | None,
+    num_frames: int | float,
+    fps: int | float,
     render_video: bool,
     progress=gr.Progress()
 ) -> tuple[str | None, str | None, str]:
@@ -84,51 +92,41 @@ def run_sharp(
     if not image_path:
         raise gr.Error("Please upload an image first.")
 
-    # Validate inputs
-    out_long_side_val = None if int(output_long_side) <= 0 else int(output_long_side)
-    
-    # Handle Trajectory Logic
-    # If mode is custom, you would ideally construct a custom camera path here.
-    # For now, we fallback to the preset if custom logic isn't fully implemented in model_utils.
-    final_traj_str = trajectory_preset
-    
-    if trajectory_mode == "Custom":
-        # Placeholder: If your model_utils supports custom params, pass them here.
-        # For this demo, we'll log it and default to a standard rotation.
-        print(f"Custom Trajectory Requested: Elev={custom_elevation}, Azim={custom_azimuth}, Rad={custom_radius}")
-        final_traj_str = "rotate" # Fallback/Default
+    # 1. Safe Integer Conversion (Handle None or Float inputs from sliders/dropdowns)
+    try:
+        # If dropdown returns 0 (Match Input), treat as None for backend
+        out_long_side_val = int(output_long_side) if output_long_side and int(output_long_side) > 0 else None
+        
+        # Sliders usually return float, convert to int safely
+        n_frames = int(num_frames) if num_frames is not None else 60
+        fps_val = int(fps) if fps is not None else 30
+    except Exception as e:
+        print(f"Input validation warning: {e}. Using defaults.")
+        out_long_side_val = None
+        n_frames = 60
+        fps_val = 30
 
-    # Convert string to Enum safely
-    # Mapping new UI names to model standard names if necessary
-    traj_map = {
-        "Orbit (Standard)": "rotate",
-        "Orbit (Forward)": "rotate_forward",
-        "Swipe Left": "swipe",
-        "Shake": "shake",
-        "Zoom In": "zoom", # Assuming model supports 'zoom', else map to closest
-        "Dolly": "dolly"
-    }
-    
-    # Get the internal key, or use the raw string if not in map
-    internal_traj_name = traj_map.get(final_traj_str, final_traj_str)
-    
-    # Resolve Enum
-    if hasattr(TrajectoryType, internal_traj_name.upper()):
-        traj_enum = TrajectoryType[internal_traj_name.upper()]
-    else:
-        # Fallback for mapped names that might match Enum directly (e.g. 'rotate')
-        traj_enum = TrajectoryType.ROTATE # Default safe fallback
-        if hasattr(TrajectoryType, internal_traj_name):
-             traj_enum = TrajectoryType[internal_traj_name]
+    # 2. Resolve Trajectory Enum safely
+    # Ensure input is a clean string
+    traj_str = str(trajectory_type_raw).strip()
+    traj_enum = traj_str # Default fallback is raw string
 
+    # Try looking up by Uppercase key (Standard Python Enum convention: TrajectoryType.ROTATE)
+    if hasattr(TrajectoryType, traj_str.upper()):
+        traj_enum = getattr(TrajectoryType, traj_str.upper())
+    # Fallback: Try looking up by exact string match if the class uses different naming
+    elif hasattr(TrajectoryType, traj_str):
+        traj_enum = getattr(TrajectoryType, traj_str)
+    
+    # 3. Run Inference
     try:
-        progress(0.1, desc="Initializing SHARP model...")
+        progress(0.1, desc="Initializing model...")
         
         video_path, ply_path = predict_and_maybe_render_gpu(
             image_path,
             trajectory_type=traj_enum,
-            num_frames=int(num_frames),
-            fps=int(fps),
+            num_frames=n_frames,
+            fps=fps_val,
             output_long_side=out_long_side_val,
             render_video=bool(render_video),
         )
@@ -136,6 +134,8 @@ def run_sharp(
         status_msg = f"✅ **Success**\n\nPLY: `{ply_path.name}`"
         if video_path:
             status_msg += f"\nVideo: `{video_path.name}`"
+        else:
+             status_msg += "\n(Video rendering skipped)"
         
         return (
             str(video_path) if video_path else None,
@@ -144,7 +144,8 @@ def run_sharp(
         )
 
     except Exception as e:
-        raise gr.Error(f"Error: {str(e)}")
+        # Catch backend errors elegantly so UI doesn't crash
+        raise gr.Error(f"Generation failed: {str(e)}")
 
 # -----------------------------------------------------------------------------
 # UI Construction
@@ -153,25 +154,24 @@ def run_sharp(
 def build_demo() -> gr.Blocks:
     theme = gr.themes.Default()
     
-    # Custom CSS only for subtle spacing, relying on Standard Gradio for layout
+    # Minimal CSS for standard centering
     css = """
     .container { max-width: 1200px; margin: auto; }
-    h1 { text-align: center; margin-bottom: 5px; }
-    .description { text-align: center; color: #666; margin-bottom: 20px; }
+    #header { text-align: center; margin-bottom: 2rem; }
     """
 
     with gr.Blocks(theme=theme, css=css, title="SHARP 3D") as demo:
         
         # --- Header ---
-        with gr.Column(elem_classes=["container"]):
+        with gr.Column(elem_id="header"):
             gr.Markdown("# SHARP: Single-Image 3D Generator")
-            gr.Markdown("Convert any static image into a 3D Gaussian Splat scene instantly.", elem_classes=["description"])
+            gr.Markdown("Convert any static image into a 3D Gaussian Splat scene instantly.")
         
-        # --- Main Two-Column Layout ---
+        # --- Main Layout (2 Columns) ---
         with gr.Row(equal_height=False):
             
-            # --- LEFT COLUMN: Input & Controls ---
-            with gr.Column(variant="panel"):
+            # LEFT: Input
+            with gr.Column():
                 image_in = gr.Image(
                     label="Input Image",
                     type="filepath",
@@ -179,55 +179,32 @@ def build_demo() -> gr.Blocks:
                     height=350
                 )
 
-                # VISIBLE Primary Configuration (Not hidden in accordion)
-                gr.Markdown("### 🎥 Camera & Quality")
                 with gr.Group():
-                    with gr.Tabs():
-                        with gr.Tab("Presets"):
-                            trajectory_mode_preset = gr.State("Preset") # Hidden state tracker
-                            trajectory_preset = gr.Dropdown(
-                                label="Movement Style",
-                                choices=[
-                                    "Orbit (Standard)", 
-                                    "Orbit (Forward)", 
-                                    "Swipe Left", 
-                                    "Shake",
-                                    "Zoom In",
-                                    "Dolly"
-                                ],
-                                value="Orbit (Forward)",
-                                interactive=True
-                            )
-                        
-                        with gr.Tab("Custom Path"):
-                            trajectory_mode_custom = gr.State("Custom")
-                            with gr.Row():
-                                cust_elev = gr.Slider(-90, 90, value=0, label="Elevation", interactive=True)
-                                cust_azim = gr.Slider(-180, 180, value=30, label="Azimuth", interactive=True)
-                            cust_rad = gr.Slider(0.5, 5.0, value=1.5, label="Radius/Distance", interactive=True)
-                            
-                            # Logic to toggle mode based on tab switch
-                            # (Simplified: We'll pass a 'mode' flag from the button click)
-
+                    gr.Markdown("### 🎥 Configuration")
+                    # Simplified Trajectory Dropdown
+                    trajectory = gr.Dropdown(
+                        label="Camera Trajectory",
+                        choices=["rotate_forward", "rotate", "swipe", "shake"],
+                        value="rotate_forward",
+                        interactive=True
+                    )
+                    
                     output_res = gr.Dropdown(
                         label="Output Resolution",
-                        choices=[("Original", 0), ("512px", 512), ("1024px", 1024)],
+                        choices=[("Match Input", 0), ("512px", 512), ("1024px", 1024)],
                         value=0,
                         interactive=True
                     )
 
-                # Advanced Configuration (Hidden)
-                with gr.Accordion("⚙️ Advanced Settings", open=False):
-                    with gr.Row():
-                        frames = gr.Slider(label="Duration (Frames)", minimum=24, maximum=120, step=1, value=60)
-                        fps_in = gr.Slider(label="Frame Rate (FPS)", minimum=8, maximum=60, step=1, value=30)
+                with gr.Accordion("Advanced Options", open=False):
+                    frames = gr.Slider(label="Duration (Frames)", minimum=24, maximum=120, step=1, value=60)
+                    fps_in = gr.Slider(label="Frame Rate (FPS)", minimum=8, maximum=60, step=1, value=30)
                     render_toggle = gr.Checkbox(label="Render Video Preview", value=True)
 
-                # Main Action Button
                 run_btn = gr.Button("🚀 Generate 3D Scene", variant="primary", size="lg")
 
-            # --- RIGHT COLUMN: Output ---
-            with gr.Column(variant="panel"):
+            # RIGHT: Output
+            with gr.Column():
                 video_out = gr.Video(
                     label="3D Preview", 
                     autoplay=True,
@@ -236,51 +213,37 @@ def build_demo() -> gr.Blocks:
                 
                 with gr.Group():
                     ply_download = gr.DownloadButton(
-                        label="Download .PLY File (For Splat Viewers)",
+                        label="Download .PLY File",
                         variant="secondary",
                         visible=True
                     )
-                    status_md = gr.Markdown("Waiting for input...", elem_id="status")
+                    status_md = gr.Markdown("Waiting for input...")
 
-        # --- Footer: Examples (Full Width) ---
-        gr.Markdown("### 📝 Examples")
+        # --- Footer: Examples ---
+        # NOTE: cache_examples=False and run_on_click=False are required
+        # to prevent crashing when clicking examples due to missing slider inputs.
         example_files = get_example_files()
-        
-        # We need a hidden component to capture the mode (Preset vs Custom)
-        # For simplicity in this demo, we default to 'Preset' mode for the button click
-        mode_state = gr.State("Preset")
-
         if example_files:
             gr.Examples(
                 examples=example_files,
                 inputs=[image_in],
-                # We do NOT run immediately here to allow user to tweak settings if they want
-                # Or set run_on_click=True if you prefer instant results
-                run_on_click=True,
-                fn=run_sharp,
-                outputs=[video_out, ply_download, status_md],
-                # We need to pass dummy defaults for the extra params since gr.Examples 
-                # usually maps strictly to inputs.
-                # To fix the "Not enough arguments" error in Examples, we usually wrap the fn.
-                # But here, we just rely on the button for complex custom logic.
-                # For basic examples, we bind the simple run.
+                outputs=None, 
+                fn=None,
+                cache_examples=False,
+                run_on_click=False, 
+                label="Click an example to load it:"
             )
-            
+
         # --- Event Binding ---
-        
-        # Helper to determine mode based on which inputs are active? 
-        # Gradio doesn't easily tell us which Tab is active in the backend function.
-        # We will assume "Preset" unless the user explicitly changes values in Custom.
-        # For this robust UI, we will just pass "Preset" mode by default.
-        
         run_btn.click(
             fn=run_sharp,
             inputs=[
                 image_in, 
-                mode_state, # Always "Preset" for now, unless we add complex JS to track tabs
-                trajectory_preset, 
-                cust_elev, cust_azim, cust_rad,
-                output_res, frames, fps_in, render_toggle
+                trajectory, 
+                output_res, 
+                frames, 
+                fps_in, 
+                render_toggle
             ],
             outputs=[video_out, ply_download, status_md],
             concurrency_limit=1
@@ -296,7 +259,5 @@ _ensure_dir(OUTPUTS_DIR)
 
 if __name__ == "__main__":
     demo = build_demo()
-    demo.queue().launch(
-        allowed_paths=[str(ASSETS_DIR)],
-        ssr_mode=False 
-    )
+    # SSR Mode False helps with stability in some Spaces environments
+    demo.queue().launch(allowed_paths=[str(ASSETS_DIR)], ssr_mode=False)