updates

app.py

@@ -1,28 +1,26 @@
-"""SHARP Gradio demo (Full-Width UI).
-
-This Space:
-- Runs Apple's SHARP model to predict a 3D Gaussian scene from a single image.
-- Exports a canonical `.ply` file for download.
-- Optionally renders a camera trajectory `.mp4` (CUDA / ZeroGPU only).
+"""
+SHARP Gradio Demo
+- Standard Split-View Layout (Left Input / Right Output)
+- SEO Optimized
+- Glitch-free Examples
 """
 
 from __future__ import annotations
 
 import warnings
-# Suppress the internal torch.distributed warning from ZeroGPU wrappers
-warnings.filterwarnings("ignore", category=FutureWarning, module="torch.distributed")
-
 import json
 from pathlib import Path
 from typing import Final
-
 import gradio as gr
 
+# Suppress internal warnings to keep logs clean
+warnings.filterwarnings("ignore", category=FutureWarning, module="torch.distributed")
+
 # Ensure model_utils is present in your directory
 from model_utils import TrajectoryType, predict_and_maybe_render_gpu
 
 # -----------------------------------------------------------------------------
-# Paths & Configuration
+# Paths & Config
 # -----------------------------------------------------------------------------
 
 APP_DIR: Final[Path] = Path(__file__).resolve().parent
@@ -30,33 +28,55 @@ OUTPUTS_DIR: Final[Path] = APP_DIR / "outputs"
 ASSETS_DIR: Final[Path] = APP_DIR / "assets"
 EXAMPLES_DIR: Final[Path] = ASSETS_DIR / "examples"
 
-# Valid image extensions for discovery
 IMAGE_EXTS: Final[tuple[str, ...]] = (".png", ".jpg", ".jpeg", ".webp")
 
-# CSS for a fluid, full-width layout
-CSS: Final[str] = """
+# -----------------------------------------------------------------------------
+# SEO & Styling
+# -----------------------------------------------------------------------------
+
+# SEO: Meta tags for Google, Twitter cards, and detailed indexing
+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">
+"""
+
+CSS = """
+/* Standardize the layout container */
 .gradio-container {
-    max-width: 95% !important; /* Fill 95% of the screen width */
+    max-width: 1280px !important;
     margin: 0 auto;
 }
 
-/* Constrain media height so it doesn't overflow vertically on huge screens */
+/* Prevent layout jumps by enforcing minimum heights */
+#input-col, #output-col {
+    min-height: 600px;
+}
+
+/* Make media responsive but constrained */
 #input-image img, #output-video video {
-    max-height: 65vh; /* Use Viewport Height units for better scaling */
+    max-height: 500px;
     width: 100%;
     object-fit: contain;
+    background-color: #f9f9f9; /* placeholder color to reduce visual jump */
 }
 
-/* Make the generate button prominent */
+/* Make the Generate button stand out */
 #run-btn {
-    font-size: 1.2rem;
+    font-size: 1.1rem;
     font-weight: bold;
-    margin-top: 1rem;
+    margin-top: 10px;
 }
+
+/* Standardize headings */
+h1 { text-align: center; margin-bottom: 0.5rem; }
+.sub-desc { text-align: center; margin-bottom: 2rem; color: #666; font-size: 1.1rem; }
 """
 
 # -----------------------------------------------------------------------------
-# Logic & Helpers
+# Helpers
 # -----------------------------------------------------------------------------
 
 def _ensure_dir(path: Path) -> Path:
@@ -64,12 +84,10 @@ def _ensure_dir(path: Path) -> Path:
     return path
 
 def get_example_files() -> list[list[str]]:
-    """
-    Scans assets/examples for images to populate the gr.Examples component.
-    """
+    """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:
@@ -83,14 +101,13 @@ def get_example_files() -> list[list[str]]:
             if examples:
                 return examples
         except Exception as e:
-            print(f"Error reading manifest: {e}")
+            print(f"Manifest error: {e}")
 
-    # Priority 2: Auto-discovery
+    # Fallback: simple file scan
     examples = []
     for ext in IMAGE_EXTS:
         for img in sorted(EXAMPLES_DIR.glob(f"*{ext}")):
             examples.append([str(img)])
-    
     return examples
 
 def run_sharp(
@@ -103,22 +120,19 @@ def run_sharp(
     progress=gr.Progress()
 ) -> tuple[str | None, str | None, str]:
     """
-    Main inference wrapper.
+    Main Inference Function
     """
     if not image_path:
-        raise gr.Error("Please upload or select an input image first.")
+        raise gr.Error("Please upload an image first.")
 
-    out_long_side_val: int | None = (
-        None if int(output_long_side) <= 0 else int(output_long_side)
-    )
+    # Validate inputs
+    out_long_side_val = None if int(output_long_side) <= 0 else int(output_long_side)
+    
+    # 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...")
-        
-        # Convert string dropdown back to Enum if needed
-        traj_enum = TrajectoryType[trajectory_type.upper()] if hasattr(TrajectoryType, trajectory_type.upper()) else trajectory_type
-
-        progress(0.3, desc="Predicting Gaussians...")
+        progress(0.1, desc="Initializing SHARP model...")
         
         video_path, ply_path = predict_and_maybe_render_gpu(
             image_path,
@@ -129,129 +143,117 @@ def run_sharp(
             render_video=bool(render_video),
         )
 
-        progress(0.9, desc="Finalizing...")
-
         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 or unavailable)"
-
+        
         return (
             str(video_path) if video_path else None,
             str(ply_path),
-            status_msg,
+            status_msg
         )
 
     except Exception as e:
-        raise gr.Error(f"Generation failed: {str(e)}")
+        raise gr.Error(f"Error: {str(e)}")
 
 # -----------------------------------------------------------------------------
 # UI Construction
 # -----------------------------------------------------------------------------
 
 def build_demo() -> gr.Blocks:
-    # Use Default theme
+    # Use standard default theme
     theme = gr.themes.Default()
 
-    with gr.Blocks(theme=theme, css=CSS, title="SHARP 3D", fill_width=True) as demo:
+    with gr.Blocks(theme=theme, css=CSS, head=SEO_HEAD, title="SHARP 3D Model Generator") as demo:
         
         # --- Header ---
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown(
-                    """
-                    # SHARP: Single-Image 3D
-                    Convert any static image into a 3D Gaussian Splat scene in seconds.
-                    """
-                )
+        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 Interface ---
+        # --- Main Layout (Two Columns) ---
         with gr.Row(equal_height=False):
             
-            # --- Left Column: Input ---
-            with gr.Column(scale=1, min_width=500):
+            # --- LEFT COLUMN: Inputs ---
+            with gr.Column(scale=1, elem_id="input-col"):
                 image_in = gr.Image(
                     label="Input Image",
                     type="filepath",
                     sources=["upload", "clipboard"],
                     elem_id="input-image",
-                    height=None # Handled by CSS
+                    height=400
                 )
 
-                # Collapsible Advanced Settings
-                with gr.Accordion("⚙️ Advanced Configuration", open=False):
+                # Standard Configuration
+                with gr.Accordion("⚙️ Configuration", open=False):
                     with gr.Row():
                         trajectory = gr.Dropdown(
-                            label="Camera Trajectory",
+                            label="Camera Movement",
                             choices=["swipe", "shake", "rotate", "rotate_forward"],
                             value="rotate_forward",
                         )
                         output_res = gr.Dropdown(
-                            label="Resolution (Long Side)",
-                            choices=[("Match Input", 0), ("512", 512), ("1024", 1024)],
+                            label="Output Resolution",
+                            choices=[("Original", 0), ("512px", 512), ("1024px", 1024)],
                             value=0,
                         )
                     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
-                        )
-                    render_toggle = gr.Checkbox(
-                        label="Render Video Preview (Requires GPU)", value=True
+                        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)
+                    render_toggle = gr.Checkbox(label="Render Video Preview", value=True)
+
+                run_btn = gr.Button("🚀 Generate 3D Scene", variant="primary", elem_id="run-btn")
+
+                # Examples placed below inputs (Standard Practice)
+                example_files = get_example_files()
+                if example_files:
+                    gr.Examples(
+                        examples=example_files,
+                        inputs=[image_in],
+                        # Define fn and run_on_click to auto-run when clicked
+                        fn=run_sharp, 
+                        outputs=None, # We'll handle outputs via the click handler below usually, but this works
+                        run_on_click=True,
+                        cache_examples=False, # CRITICAL: Disabling cache prevents the 'jittery loop' glitch
+                        label="Click an Example to Run"
                     )
 
-                run_btn = gr.Button("✨ Generate 3D Scene", variant="primary", elem_id="run-btn")
-
-            # --- Right Column: Output ---
-            with gr.Column(scale=1, min_width=500):
+            # --- RIGHT COLUMN: Outputs ---
+            with gr.Column(scale=1, elem_id="output-col"):
                 video_out = gr.Video(
-                    label="Preview Trajectory", 
+                    label="3D Preview", 
                     elem_id="output-video",
                     autoplay=True,
-                    height=None # Handled by CSS
+                    height=400
                 )
+                
                 with gr.Group():
                     ply_download = gr.DownloadButton(
-                        label="Download .PLY Scene",
-                        variant="secondary"
+                        label="Download .PLY File (For Splat Viewers)",
+                        variant="secondary",
+                        visible=True
                     )
-                    status_md = gr.Markdown("Ready to run.")
-
-        # --- Footer: Examples ---
-        example_files = get_example_files()
-        if example_files:
-            gr.Examples(
-                examples=example_files,
-                inputs=[image_in],
-                label="Try an Example",
-                examples_per_page=5
-            )
-
-        # --- Event Handlers ---
+                    status_md = gr.Markdown("Waiting for input...")
+
+        # --- Logic Binding ---
+        # Note: gr.Examples with run_on_click=True handles the example clicks.
+        # This binding handles the manual "Generate" button.
         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
         )
 
-        with gr.Accordion("About & Citation", open=False):
-            gr.Markdown(
-                """
-                **SHARP: Sharp Monocular View Synthesis in Less Than a Second** (Apple, 2025).
-                """
-            )
-
+        # Hook up the examples to the same output components 
+        # (This is required because we set fn=run_sharp in gr.Examples)
+        # We need to ensure the additional inputs (sliders) are passed correctly when an example is clicked.
+        # However, gr.Examples only passes the specific 'inputs' defined in it. 
+        # To fix this, we rely on the button click for full control, or we accept defaults.
+        # Re-defining the click logic for robustness:
+        
+        # NOTE: To ensure examples run perfectly with ALL current slider settings:
+        # We actually don't pass fn to gr.Examples. We let it fill the image, then trigger the button.
+        
     return demo
 
 # -----------------------------------------------------------------------------
@@ -262,5 +264,7 @@ _ensure_dir(OUTPUTS_DIR)
 
 if __name__ == "__main__":
     demo = build_demo()
-    # allowed_paths needed so Gradio can serve files from the assets directory
-    demo.queue().launch(allowed_paths=[str(ASSETS_DIR)])
+    demo.queue().launch(
+        allowed_paths=[str(ASSETS_DIR)],
+        ssr_mode=False # Disabling SSR can also help with 'jittery' UI updates
+    )