updates

app.py

@@ -1,8 +1,8 @@
 """
 SHARP Gradio Demo
-- Standard Two-Column Layout
-- Simplified Camera options
-- Robust Error Handling
+- Standard Split-View Layout (Left Input / Right Output)
+- SEO Optimized
+- Configs Visible (No Accordion)
 """
 
 from __future__ import annotations
@@ -16,20 +16,8 @@ import gradio as gr
 # Suppress internal warnings to keep logs clean
 warnings.filterwarnings("ignore", category=FutureWarning, module="torch.distributed")
 
-# Ensure model_utils is present
-# 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")
+# Ensure model_utils is present in your directory
+from model_utils import TrajectoryType, predict_and_maybe_render_gpu
 
 # -----------------------------------------------------------------------------
 # Paths & Config
@@ -42,6 +30,25 @@ EXAMPLES_DIR: Final[Path] = ASSETS_DIR / "examples"
 
 IMAGE_EXTS: Final[tuple[str, ...]] = (".png", ".jpg", ".jpeg", ".webp")
 
+# -----------------------------------------------------------------------------
+# SEO & Styling
+# -----------------------------------------------------------------------------
+
+SEO_HEAD = """
+<meta name="description" content="Turn 2D images into 3D Gaussian Splats instantly. SHARP (Apple) AI Demo. Free, fast, single-image 3D reconstruction.">
+<meta name="keywords" content="SHARP, 3D Gaussian Splatting, AI 3D model, Image to 3D, Apple Research, Gradio, Machine Learning">
+<meta property="og:title" content="SHARP: Instant Image-to-3D Model">
+<meta property="og:description" content="Generate 3D camera trajectories and PLY files from a single image in seconds using the SHARP model.">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+"""
+
+# Minimal CSS to just center headers and ensure spacing
+CSS = """
+h1 { text-align: center; margin-bottom: 0.5rem; }
+.sub-desc { text-align: center; margin-bottom: 2rem; color: #666; font-size: 1.1rem; }
+.gradio-container { max-width: 1400px !important; margin: 0 auto; }
+"""
+
 # -----------------------------------------------------------------------------
 # Helpers
 # -----------------------------------------------------------------------------
@@ -54,7 +61,7 @@ def get_example_files() -> list[list[str]]:
     """Discover images in assets/examples for the UI."""
     _ensure_dir(EXAMPLES_DIR)
     
-    # Priority 1: Check manifest.json
+    # Check manifest.json first
     manifest_path = EXAMPLES_DIR / "manifest.json"
     if manifest_path.exists():
         try:
@@ -70,7 +77,7 @@ def get_example_files() -> list[list[str]]:
         except Exception as e:
             print(f"Manifest error: {e}")
 
-    # Priority 2: Simple file scan
+    # Fallback: simple file scan
     examples = []
     for ext in IMAGE_EXTS:
         for img in sorted(EXAMPLES_DIR.glob(f"*{ext}")):
@@ -79,10 +86,10 @@ def get_example_files() -> list[list[str]]:
 
 def run_sharp(
     image_path: str | None,
-    trajectory_type_raw: str,
-    output_long_side: int | float | None,
-    num_frames: int | float,
-    fps: int | float,
+    trajectory_type: str,
+    output_long_side: int,
+    num_frames: int,
+    fps: int,
     render_video: bool,
     progress=gr.Progress()
 ) -> tuple[str | None, str | None, str]:
@@ -92,41 +99,20 @@ def run_sharp(
     if not image_path:
         raise gr.Error("Please upload an image first.")
 
-    # 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
-
-    # 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)
+    # Validate inputs
+    out_long_side_val = None if int(output_long_side) <= 0 else int(output_long_side)
     
-    # 3. Run Inference
+    # Convert trajectory string to Enum or pass as is
+    traj_enum = TrajectoryType[trajectory_type.upper()] if hasattr(TrajectoryType, trajectory_type.upper()) else trajectory_type
+
     try:
-        progress(0.1, desc="Initializing model...")
+        progress(0.1, desc="Initializing SHARP model...")
         
         video_path, ply_path = predict_and_maybe_render_gpu(
             image_path,
             trajectory_type=traj_enum,
-            num_frames=n_frames,
-            fps=fps_val,
+            num_frames=int(num_frames),
+            fps=int(fps),
             output_long_side=out_long_side_val,
             render_video=bool(render_video),
         )
@@ -134,8 +120,6 @@ 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,8 +128,7 @@ def run_sharp(
         )
 
     except Exception as e:
-        # Catch backend errors elegantly so UI doesn't crash
-        raise gr.Error(f"Generation failed: {str(e)}")
+        raise gr.Error(f"Error: {str(e)}")
 
 # -----------------------------------------------------------------------------
 # UI Construction
@@ -153,102 +136,86 @@ def run_sharp(
 
 def build_demo() -> gr.Blocks:
     theme = gr.themes.Default()
-    
-    # Minimal CSS for standard centering
-    css = """
-    .container { max-width: 1200px; margin: auto; }
-    #header { text-align: center; margin-bottom: 2rem; }
-    """
 
-    with gr.Blocks(theme=theme, css=css, title="SHARP 3D") as demo:
+    with gr.Blocks(theme=theme, css=CSS, head=SEO_HEAD, title="SHARP 3D Model Generator") as demo:
         
         # --- Header ---
-        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.")
+        gr.Markdown("# SHARP: Single-Image 3D Generator")
+        gr.Markdown("Convert any static image into a 3D Gaussian Splat scene instantly.", elem_classes=["sub-desc"])
         
-        # --- Main Layout (2 Columns) ---
-        with gr.Row(equal_height=False):
+        # --- Main Layout (Strict Two Columns) ---
+        with gr.Row(equal_height=False, variant="panel"):
             
-            # LEFT: Input
-            with gr.Column():
+            # --- LEFT COLUMN: Input & Controls ---
+            with gr.Column(scale=1):
                 image_in = gr.Image(
                     label="Input Image",
                     type="filepath",
                     sources=["upload", "clipboard"],
-                    height=350
+                    height=320,  # Fixed height to prevent layout shifts
+                    interactive=True
                 )
 
+                # Settings grouped cleanly below image (No Accordion)
                 with gr.Group():
-                    gr.Markdown("### 🎥 Configuration")
-                    # Simplified Trajectory Dropdown
-                    trajectory = gr.Dropdown(
-                        label="Camera Trajectory",
-                        choices=["rotate_forward", "rotate", "swipe", "shake"],
-                        value="rotate_forward",
-                        interactive=True
-                    )
+                    with gr.Row():
+                        trajectory = gr.Dropdown(
+                            label="Camera Movement",
+                            choices=["swipe", "shake", "rotate", "rotate_forward"],
+                            value="rotate_forward",
+                            scale=2
+                        )
+                        output_res = gr.Dropdown(
+                            label="Output Resolution",
+                            choices=[("Original", 0), ("512px", 512), ("1024px", 1024)],
+                            value=0,
+                            scale=1
+                        )
+                    with gr.Row():
+                        frames = gr.Slider(label="Frames", minimum=24, maximum=120, step=1, value=60)
+                        fps_in = gr.Slider(label="FPS", minimum=8, maximum=60, step=1, value=30)
                     
-                    output_res = gr.Dropdown(
-                        label="Output Resolution",
-                        choices=[("Match Input", 0), ("512px", 512), ("1024px", 1024)],
-                        value=0,
-                        interactive=True
-                    )
-
-                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)
 
                 run_btn = gr.Button("🚀 Generate 3D Scene", variant="primary", size="lg")
 
-            # RIGHT: Output
-            with gr.Column():
+                # Examples at the bottom of left column
+                example_files = get_example_files()
+                if example_files:
+                    gr.Examples(
+                        examples=example_files,
+                        inputs=[image_in],
+                        label="Examples (Click to Load)",
+                        # Setting run_on_click=False allows user to change settings before running
+                        run_on_click=False, 
+                        cache_examples=False
+                    )
+
+            # --- RIGHT COLUMN: Output ---
+            with gr.Column(scale=1):
                 video_out = gr.Video(
                     label="3D Preview", 
                     autoplay=True,
-                    height=350
+                    height=320, # Matches input height
+                    elem_id="output-video"
                 )
                 
                 with gr.Group():
+                    status_md = gr.Markdown("Ready to generate.")
                     ply_download = gr.DownloadButton(
-                        label="Download .PLY File",
+                        label="Download .PLY File (For Splat Viewers)",
                         variant="secondary",
                         visible=True
                     )
-                    status_md = gr.Markdown("Waiting for input...")
-
-        # --- 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()
-        if example_files:
-            gr.Examples(
-                examples=example_files,
-                inputs=[image_in],
-                outputs=None, 
-                fn=None,
-                cache_examples=False,
-                run_on_click=False, 
-                label="Click an example to load it:"
-            )
 
-        # --- Event Binding ---
+        # --- Logic Binding ---
         run_btn.click(
             fn=run_sharp,
-            inputs=[
-                image_in, 
-                trajectory, 
-                output_res, 
-                frames, 
-                fps_in, 
-                render_toggle
-            ],
+            inputs=[image_in, trajectory, output_res, frames, fps_in, render_toggle],
             outputs=[video_out, ply_download, status_md],
             concurrency_limit=1
         )
-
+        
     return demo
 
 # -----------------------------------------------------------------------------
@@ -259,5 +226,7 @@ _ensure_dir(OUTPUTS_DIR)
 
 if __name__ == "__main__":
     demo = build_demo()
-    # SSR Mode False helps with stability in some Spaces environments
-    demo.queue().launch(allowed_paths=[str(ASSETS_DIR)], ssr_mode=False)
+    demo.queue().launch(
+        allowed_paths=[str(ASSETS_DIR)],
+        ssr_mode=False
+    )