Convert to pure Gradio app for ZeroGPU compatibility

- Remove FastAPI integration (not compatible with ZeroGPU)
- Use Gradio-only approach with @spaces.GPU decorators
- Simplify to standard Gradio Space architecture
- Remove Dockerfile (Spaces use Python + requirements.txt)
- Update README.md sdk_version to match requirements
- Keep camera intrinsics inputs with defaults

ZeroGPU Spaces work best with pure Gradio applications.
API access still available via gradio_client library.

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

README.md

@@ -4,16 +4,15 @@ emoji: 🎯
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 6.4.0
-python_version: '3.12'
+sdk_version: 4.50.0
 app_file: app.py
 pinned: false
+hf_oauth: false
 tags:
   - computer-vision
   - 6D-pose
   - object-detection
   - robotics
-  - zero-gpu
 ---
 
 # FoundationPose Inference Server

app.py

@@ -1,7 +1,7 @@
 """
-Simple FoundationPose API server using FastAPI + Gradio
+FoundationPose inference server for Hugging Face Spaces with ZeroGPU.
 
-This version uses FastAPI for clean REST API endpoints alongside Gradio UI.
+This version uses pure Gradio for ZeroGPU compatibility.
 """
 
 import base64
@@ -15,8 +15,6 @@ import gradio as gr
 import numpy as np
 import spaces
 import torch
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
 
 logging.basicConfig(
     level=logging.INFO,
@@ -38,7 +36,6 @@ class FoundationPoseInference:
         self.tracked_objects = {}
         self.use_real_model = USE_REAL_MODEL
 
-    @spaces.GPU(duration=120)
     def initialize_model(self):
         """Initialize the FoundationPose model on GPU."""
         if self.initialized:
@@ -167,112 +164,8 @@ class FoundationPoseInference:
 pose_estimator = FoundationPoseInference()
 
 
-# Pydantic models for API
-class InitializeRequest(BaseModel):
-    object_id: str
-    reference_images_b64: List[str]
-    camera_intrinsics: str = None
-    mesh_path: str = None
-
-
-class EstimateRequest(BaseModel):
-    object_id: str
-    query_image_b64: str
-    camera_intrinsics: str = None
-    depth_image_b64: str = None
-    mask_b64: str = None
-
-
-# Create FastAPI app
-app = FastAPI()
-
-
-@app.post("/api/initialize")
-async def api_initialize(request: InitializeRequest):
-    """Initialize object tracking with reference images."""
-    try:
-        # Decode reference images
-        reference_images = []
-        for img_b64 in request.reference_images_b64:
-            img_bytes = base64.b64decode(img_b64)
-            img_array = np.frombuffer(img_bytes, dtype=np.uint8)
-            img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            reference_images.append(img)
-
-        # Parse camera intrinsics
-        intrinsics = json.loads(request.camera_intrinsics) if request.camera_intrinsics else None
-
-        # Register object
-        success = pose_estimator.register_object(
-            object_id=request.object_id,
-            reference_images=reference_images,
-            camera_intrinsics=intrinsics,
-            mesh_path=request.mesh_path
-        )
-
-        return {
-            "success": success,
-            "message": f"Object '{request.object_id}' registered with {len(reference_images)} reference images"
-        }
-
-    except Exception as e:
-        logger.error(f"Initialization error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/estimate")
-async def api_estimate(request: EstimateRequest):
-    """Estimate 6D pose from query image."""
-    try:
-        # Decode query image
-        img_bytes = base64.b64decode(request.query_image_b64)
-        img_array = np.frombuffer(img_bytes, dtype=np.uint8)
-        img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
-        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-
-        # Decode optional depth image
-        depth = None
-        if request.depth_image_b64:
-            depth_bytes = base64.b64decode(request.depth_image_b64)
-            depth = np.frombuffer(depth_bytes, dtype=np.float32)
-
-        # Decode optional mask
-        mask = None
-        if request.mask_b64:
-            mask_bytes = base64.b64decode(request.mask_b64)
-            mask_array = np.frombuffer(mask_bytes, dtype=np.uint8)
-            mask = cv2.imdecode(mask_array, cv2.IMREAD_GRAYSCALE)
-
-        # Parse camera intrinsics
-        intrinsics = json.loads(request.camera_intrinsics) if request.camera_intrinsics else None
-
-        # Estimate pose
-        result = pose_estimator.estimate_pose(
-            object_id=request.object_id,
-            query_image=img,
-            camera_intrinsics=intrinsics,
-            depth_image=depth,
-            mask=mask
-        )
-
-        return result
-
-    except Exception as e:
-        logger.error(f"Estimation error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# Warmup function to ensure ZeroGPU detects GPU usage
-@spaces.GPU(duration=10)
-def warmup():
-    """Warmup function to initialize GPU context for ZeroGPU."""
-    logger.info("Warming up GPU for ZeroGPU...")
-    pose_estimator.initialize_model()
-    return "✓ GPU initialized"
-
-
-# Gradio wrapper functions
+# Gradio wrapper functions with @spaces.GPU decorators
+@spaces.GPU(duration=120)
 def gradio_initialize(object_id: str, reference_files: List, fx: float, fy: float, cx: float, cy: float):
     """Gradio wrapper for object initialization."""
     try:
@@ -316,6 +209,7 @@ def gradio_initialize(object_id: str, reference_files: List, fx: float, fy: floa
         return f"Error: {str(e)}"
 
 
+@spaces.GPU(duration=30)
 def gradio_estimate(object_id: str, query_image: np.ndarray, fx: float, fy: float, cx: float, cy: float):
     """Gradio wrapper for pose estimation."""
     try:
@@ -383,8 +277,8 @@ def gradio_estimate(object_id: str, query_image: np.ndarray, fx: float, fy: floa
         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:
+# Gradio UI
+with gr.Blocks(title="FoundationPose Inference", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎯 FoundationPose 6D Object Pose Estimation")
 
     mode_indicator = gr.Markdown(
@@ -483,22 +377,35 @@ with gr.Blocks(title="FoundationPose Inference", theme=gr.themes.Soft()) as grad
 
     gr.Markdown("""
     ---
-    ## REST API Endpoints
+    ## API Documentation
 
-    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
+    This Space uses Gradio's built-in API. For programmatic access, use the `gradio_client` library:
 
-    See the [API documentation](https://huggingface.co/spaces/gpue/foundationpose) for details.
-    """)
+    ```python
+    from gradio_client import Client
 
-    # Warmup on load to ensure ZeroGPU detects GPU usage
-    gradio_app.load(warmup, outputs=None)
+    client = Client("https://gpue-foundationpose.hf.space")
 
+    # Initialize object
+    result = client.predict(
+        object_id="target_cube",
+        reference_files=[file1, file2, ...],
+        fx=500.0, fy=500.0, cx=320.0, cy=240.0,
+        api_name="/gradio_initialize"
+    )
+
+    # Estimate pose
+    result = client.predict(
+        object_id="target_cube",
+        query_image=image,
+        fx=500.0, fy=500.0, cx=320.0, cy=240.0,
+        api_name="/gradio_estimate"
+    )
+    ```
+
+    See [client.py](https://huggingface.co/spaces/gpue/foundationpose/blob/main/client.py) for a complete example.
+    """)
 
-# Mount Gradio to FastAPI
-app = gr.mount_gradio_app(app, gradio_app, path="/")
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.launch()