Fix ZeroGPU startup error by adding proper Gradio UI

- Add gradio_initialize() and gradio_estimate() wrapper functions
- Create two-tab UI: Initialize Object and Estimate Pose
- Add camera intrinsics inputs (fx, fy, cx, cy) with defaults (500, 500, 320, 240)
- Add File upload for reference images (multiple files)
- Add Image upload for query image
- Connect buttons to @spaces.GPU decorated functions via wrappers
- Keep FastAPI REST endpoints alongside Gradio UI

This fixes: 'No @spaces.GPU function detected during startup'

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

app.py

@@ -264,7 +264,118 @@ async def api_estimate(request: EstimateRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-# Gradio UI (simplified)
+# Gradio wrapper functions
+def gradio_initialize(object_id: str, reference_files: List, fx: float, fy: float, cx: float, cy: float):
+    """Gradio wrapper for object initialization."""
+    try:
+        if not reference_files:
+            return "Error: No reference images provided"
+
+        # Load reference images
+        reference_images = []
+        for file in reference_files:
+            img = cv2.imread(file.name)
+            if img is None:
+                continue
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            reference_images.append(img)
+
+        if not reference_images:
+            return "Error: Could not load any reference images"
+
+        # Prepare camera intrinsics
+        camera_intrinsics = {
+            "fx": fx,
+            "fy": fy,
+            "cx": cx,
+            "cy": cy
+        }
+
+        # Register object (calls @spaces.GPU decorated method)
+        success = pose_estimator.register_object(
+            object_id=object_id,
+            reference_images=reference_images,
+            camera_intrinsics=camera_intrinsics
+        )
+
+        if success:
+            return f"✓ Object '{object_id}' initialized with {len(reference_images)} reference images"
+        else:
+            return f"✗ Failed to initialize object '{object_id}'"
+
+    except Exception as e:
+        logger.error(f"Gradio initialization error: {e}", exc_info=True)
+        return f"Error: {str(e)}"
+
+
+def gradio_estimate(object_id: str, query_image: np.ndarray, fx: float, fy: float, cx: float, cy: float):
+    """Gradio wrapper for pose estimation."""
+    try:
+        if query_image is None:
+            return "Error: No query image provided", None
+
+        # Prepare camera intrinsics
+        camera_intrinsics = {
+            "fx": fx,
+            "fy": fy,
+            "cx": cx,
+            "cy": cy
+        }
+
+        # Estimate pose (calls @spaces.GPU decorated method)
+        result = pose_estimator.estimate_pose(
+            object_id=object_id,
+            query_image=query_image,
+            camera_intrinsics=camera_intrinsics
+        )
+
+        if not result.get("success"):
+            error = result.get("error", "Unknown error")
+            return f"✗ Estimation failed: {error}", None
+
+        poses = result.get("poses", [])
+        note = result.get("note", "")
+
+        # Format output
+        if not poses:
+            output = "⚠ No poses detected\n"
+            if note:
+                output += f"\nNote: {note}"
+            return output, query_image
+
+        output = f"✓ Detected {len(poses)} pose(s):\n\n"
+        for i, pose in enumerate(poses):
+            output += f"Pose {i + 1}:\n"
+            output += f"  Object ID: {pose.get('object_id', 'unknown')}\n"
+
+            if 'position' in pose:
+                pos = pose['position']
+                output += f"  Position:\n"
+                output += f"    x: {pos.get('x', 0):.4f} m\n"
+                output += f"    y: {pos.get('y', 0):.4f} m\n"
+                output += f"    z: {pos.get('z', 0):.4f} m\n"
+
+            if 'orientation' in pose:
+                ori = pose['orientation']
+                output += f"  Orientation (quaternion):\n"
+                output += f"    w: {ori.get('w', 0):.4f}\n"
+                output += f"    x: {ori.get('x', 0):.4f}\n"
+                output += f"    y: {ori.get('y', 0):.4f}\n"
+                output += f"    z: {ori.get('z', 0):.4f}\n"
+
+            if 'confidence' in pose:
+                output += f"  Confidence: {pose['confidence']:.2%}\n"
+
+            output += "\n"
+
+        return output, query_image
+
+    except Exception as e:
+        logger.error(f"Gradio estimation error: {e}", exc_info=True)
+        return f"Error: {str(e)}", None
+
+
+# Gradio UI with proper @spaces.GPU function calls
 with gr.Blocks(title="FoundationPose Inference", theme=gr.themes.Soft()) as gradio_app:
     gr.Markdown("# 🎯 FoundationPose 6D Object Pose Estimation")
 
@@ -273,12 +384,104 @@ with gr.Blocks(title="FoundationPose Inference", theme=gr.themes.Soft()) as grad
         elem_id="mode"
     )
 
+    with gr.Tabs():
+        # Tab 1: Initialize Object
+        with gr.Tab("Initialize Object"):
+            gr.Markdown("""
+            Upload reference images of your object from different angles (8-20 images recommended).
+            The model will learn the object's appearance for pose estimation.
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    init_object_id = gr.Textbox(
+                        label="Object ID",
+                        placeholder="e.g., target_cube",
+                        value="target_cube"
+                    )
+
+                    init_ref_files = gr.File(
+                        label="Reference Images",
+                        file_count="multiple",
+                        file_types=["image"]
+                    )
+
+                    gr.Markdown("### Camera Intrinsics")
+                    with gr.Row():
+                        init_fx = gr.Number(label="fx (focal length x)", value=500.0)
+                        init_fy = gr.Number(label="fy (focal length y)", value=500.0)
+                    with gr.Row():
+                        init_cx = gr.Number(label="cx (principal point x)", value=320.0)
+                        init_cy = gr.Number(label="cy (principal point y)", value=240.0)
+
+                    init_button = gr.Button("Initialize Object", variant="primary")
+
+                with gr.Column():
+                    init_output = gr.Textbox(
+                        label="Initialization Result",
+                        lines=5,
+                        interactive=False
+                    )
+
+            init_button.click(
+                fn=gradio_initialize,
+                inputs=[init_object_id, init_ref_files, init_fx, init_fy, init_cx, init_cy],
+                outputs=init_output
+            )
+
+        # Tab 2: Estimate Pose
+        with gr.Tab("Estimate Pose"):
+            gr.Markdown("""
+            Upload a query image containing the initialized object.
+            The model will estimate the 6D pose (position + orientation).
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    est_object_id = gr.Textbox(
+                        label="Object ID",
+                        placeholder="e.g., target_cube",
+                        value="target_cube"
+                    )
+
+                    est_query_image = gr.Image(
+                        label="Query Image",
+                        type="numpy"
+                    )
+
+                    gr.Markdown("### Camera Intrinsics")
+                    with gr.Row():
+                        est_fx = gr.Number(label="fx (focal length x)", value=500.0)
+                        est_fy = gr.Number(label="fy (focal length y)", value=500.0)
+                    with gr.Row():
+                        est_cx = gr.Number(label="cx (principal point x)", value=320.0)
+                        est_cy = gr.Number(label="cy (principal point y)", value=240.0)
+
+                    est_button = gr.Button("Estimate Pose", variant="primary")
+
+                with gr.Column():
+                    est_output = gr.Textbox(
+                        label="Pose Estimation Result",
+                        lines=15,
+                        interactive=False
+                    )
+                    est_viz = gr.Image(label="Query Image")
+
+            est_button.click(
+                fn=gradio_estimate,
+                inputs=[est_object_id, est_query_image, est_fx, est_fy, est_cx, est_cy],
+                outputs=[est_output, est_viz]
+            )
+
     gr.Markdown("""
-    API Endpoints:
-    - POST `/api/initialize` - Register object
-    - POST `/api/estimate` - Estimate pose
+    ---
+    ## REST API Endpoints
+
+    This Space also provides REST API endpoints for programmatic access:
+    - POST `/api/initialize` - Register object with reference images
+    - POST `/api/estimate` - Estimate 6D pose from query image
 
-    See documentation for usage examples.
+    See the [API documentation](https://huggingface.co/spaces/gpue/foundationpose) for details.
     """)