Receive data in multipart/form-data instead of base64

API_README.md

@@ -34,20 +34,21 @@ Check if the service is running.
 
 Start a 3D model generation job.
 
-**Request Body:**
+**Request Format:**
+Multipart/form-data with the following fields:
+
+- `front`: (Required) Front view image file
+- `back`: (Optional) Back view image file
+- `left`: (Optional) Left view image file
+- `right`: (Optional) Right view image file
+- `options`: (Optional) JSON string with generation options
+
+**Options JSON Format:**
 ```json
 {
-  "images": {
-    "front": "base64_encoded_image",
-    "back": "base64_encoded_image",  // Optional
-    "left": "base64_encoded_image",  // Optional
-    "right": "base64_encoded_image"  // Optional
-  },
-  "options": {
-    "enable_pbr": true,
-    "should_remesh": true,
-    "should_texture": true
-  }
+  "enable_pbr": true,
+  "should_remesh": true,
+  "should_texture": true
 }
 ```
 
@@ -60,10 +61,9 @@ Start a 3D model generation job.
 ```
 
 **Notes:**
-- At least one image is required
 - The `front` image is mandatory
-- Images should be base64 encoded
-- The `options` object is optional and will use defaults if not provided
+- Images should be uploaded as files in multipart/form-data format
+- The `options` field is optional and will use defaults if not provided
 - **Texture generation is enabled by default for high-quality 3D models**
 
 ### 3. Check Job Status
@@ -104,22 +104,30 @@ Check the status of a generation job.
 ### Python Example
 ```python
 import requests
-import base64
+import json
+import time
+
+# Prepare files and options
+files = {
+    'front': ('front.png', open('front.png', 'rb'), 'image/png'),
+    # Optional additional views
+    # 'back': ('back.png', open('back.png', 'rb'), 'image/png'),
+    # 'left': ('left.png', open('left.png', 'rb'), 'image/png'),
+    # 'right': ('right.png', open('right.png', 'rb'), 'image/png'),
+}
 
-# Encode image
-with open("image.png", "rb") as f:
-    image_base64 = base64.b64encode(f.read()).decode()
+options = {
+    "enable_pbr": True,
+    "should_texture": True,  # Critical for 3D model quality
+    "should_remesh": True
+}
 
 # Start generation
-response = requests.post("http://localhost:7860/api/generate", json={
-    "images": {
-        "front": image_base64
-    },
-    "options": {
-        "enable_pbr": True,
-        "should_texture": True  # Critical for 3D model quality
-    }
-})
+response = requests.post(
+    "http://localhost:7860/api/generate",
+    files=files,
+    data={'options': json.dumps(options)}
+)
 
 job_id = response.json()["job_id"]
 
@@ -146,16 +154,8 @@ curl http://localhost:7860/api/health
 
 # Generate model
 curl -X POST http://localhost:7860/api/generate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "images": {
-      "front": "base64_encoded_image_here"
-    },
-    "options": {
-      "enable_pbr": true,
-      "should_texture": true
-    }
-  }'
+  -F "front=@front.png" \
+  -F 'options={"enable_pbr":true,"should_texture":true}'
 
 # Check status
 curl "http://localhost:7860/api/status?job_id=your_job_id"

gradio_app.py

@@ -65,7 +65,7 @@ import gradio as gr
 import torch
 import trimesh
 import uvicorn
-from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi import FastAPI, HTTPException, BackgroundTasks, File, Form, UploadFile
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
@@ -86,13 +86,10 @@ class JobStatus(Enum):
     FAILED = "failed"
 
 
-class GenerateRequest(BaseModel):
-    images: Dict[str, str]  # base64 encoded images
-    options: Dict[str, Any] = {
-        "enable_pbr": True,
-        "should_remesh": True,
-        "should_texture": True  # Critical for 3D model quality
-    }
+class GenerateOptions(BaseModel):
+    enable_pbr: bool = True
+    should_remesh: bool = True
+    should_texture: bool = True  # Critical for 3D model quality
 
 
 class JobInfo:
@@ -168,17 +165,15 @@ def base64_to_pil_image(base64_string: str) -> Image.Image:
         raise HTTPException(status_code=400, detail=f"Invalid image data: {str(e)}")
 
 
-def process_generation_job(job_id: str, images: Dict[str, str], options: Dict[str, Any]):
+def process_generation_job(job_id: str, images: Dict[str, Image.Image], options: Dict[str, Any]):
     """Background task to process generation job."""
     global face_reduce_worker, tex_pipeline, HAS_TEXTUREGEN, SAVE_DIR
     
     try:
         update_job_status(job_id, JobStatus.PROCESSING, progress=10, stage="initializing")
         
-        # Convert base64 images to PIL Images
-        pil_images = {}
-        for view, base64_img in images.items():
-            pil_images[view] = base64_to_pil_image(base64_img)
+        # Images are already PIL Images
+        pil_images = images
         
         # Extract options
         enable_pbr = options.get("enable_pbr", True)
@@ -1324,29 +1319,61 @@ if __name__ == '__main__':
     
     # API Endpoints
     @app.post("/api/generate")
-    async def generate_3d_model(request: GenerateRequest, background_tasks: BackgroundTasks):
-        """Generate 3D model from images."""
+    async def generate_3d_model(
+        front: UploadFile = File(None),
+        back: UploadFile = File(None),
+        left: UploadFile = File(None),
+        right: UploadFile = File(None),
+        options: str = Form("{}"),
+        background_tasks: BackgroundTasks = BackgroundTasks()
+    ):
+        """Generate 3D model from images using multipart/form-data."""
         try:
-            # Validate input
-            if not request.images:
-                raise HTTPException(status_code=400, detail="At least one image is required")
+            # Parse options
+            options_dict = json.loads(options) if options else {}
+            generate_options = {
+                "enable_pbr": options_dict.get("enable_pbr", True),
+                "should_remesh": options_dict.get("should_remesh", True),
+                "should_texture": options_dict.get("should_texture", True)
+            }
+            
+            # Process uploaded files
+            images = {}
             
-            if 'front' not in request.images:
+            # Validate input - at least one image is required
+            if not front:
                 raise HTTPException(status_code=400, detail="Front image is required")
+                
+            # Process each uploaded file
+            for view, file in {
+                "front": front,
+                "back": back,
+                "left": left,
+                "right": right
+            }.items():
+                if file and file.filename:
+                    # Read file content
+                    contents = await file.read()
+                    # Convert to PIL Image
+                    try:
+                        img = Image.open(io.BytesIO(contents))
+                        images[view] = img
+                    except Exception as e:
+                        raise HTTPException(status_code=400, detail=f"Invalid image for {view}: {str(e)}")
             
             # Create job
             job_id = create_job()
             
-            # Store job data
-            jobs[job_id].images = request.images
-            jobs[job_id].options = request.options
+            # Store job data (store file paths instead of actual images)
+            jobs[job_id].images = {k: "<uploaded_file>" for k in images.keys()}
+            jobs[job_id].options = generate_options
             
             # Start background task
             background_tasks.add_task(
                 process_generation_job, 
                 job_id, 
-                request.images, 
-                request.options
+                images, 
+                generate_options
             )
             
             return JSONResponse({