1

Dockerfile

@@ -0,0 +1,69 @@
+FROM python:3.11.12-slim
+#3.10-slim
+
+
+ENV NUMBA_CACHE_DIR=/tmp
+ENV HF_HOME=/tmp/huggingface
+ENV TRANSFORMERS_CACHE=/tmp/huggingface/transformers
+ENV HF_HUB_CACHE=/tmp/huggingface/hub
+
+WORKDIR /app
+
+
+
+RUN mkdir -p /app/tmp && chmod -R 777 /app/tmp
+RUN mkdir -p /app/tmp/huggingface/token && chmod -R 777 /app/tmp/huggingface/token
+# Install git, build tools, and dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    build-essential \
+    cmake \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    && rm -rf /var/lib/apt/lists/*
+    
+
+# Clone the repository
+RUN git clone https://github.com/Stability-AI/stable-fast-3d.git
+
+# Install PyTorch first (needed for the local package builds)
+RUN pip install --no-cache-dir torch==2.6.0
+#2.1.0
+
+# Install Python dependencies (except local packages)
+# Create a modified requirements file without the local packages
+RUN grep -v "^\./" stable-fast-3d/requirements.txt > modified_requirements.txt && \
+    pip install --no-cache-dir -r modified_requirements.txt
+
+# Install the local packages
+# First texture_baker
+WORKDIR /app/stable-fast-3d/texture_baker
+RUN pip install -e .
+# Then uv_unwrapper
+WORKDIR /app/stable-fast-3d/uv_unwrapper
+RUN pip install -e .
+# Return to app directory
+WORKDIR /app
+# Copy the FastAPI application code
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir transformers==4.38.1 huggingface_hub==0.20.3
+
+
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+COPY --chown=user app/ app/
+COPY --chown=user main.py .
+
+# Expose the port the app will run on
+EXPOSE 7860
+
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,8 @@
 ---
 title: 3D Model AI
-emoji: 😻
-colorFrom: red
-colorTo: blue
+emoji: 🌍
+colorFrom: gray
+colorTo: green
 sdk: docker
 pinned: false
 ---

app/utils.py

@@ -0,0 +1,84 @@
+import subprocess
+import os
+from pathlib import Path
+import glob
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def run_inference(image_path: str, output_dir: str):
+    """
+    Run Stable Fast 3D inference on the input image
+    
+    Args:
+        image_path: Path to the input image
+        output_dir: Directory to save output files
+        
+    Returns:
+        Path to the generated GLB file
+    """
+    # Get the repository path
+    repo_path = Path("/app/stable-fast-3d")
+
+    
+    logger.info(f"Running inference on image: {image_path}")
+    logger.info(f"Output directory: {output_dir}")
+    
+    # Run the model
+    command = [
+        "python", "run.py",
+        image_path,
+        "--output-dir", output_dir,
+        "--pretrained-model", "stabilityai/stable-fast-3d",
+        "--texture-resolution", "2048",
+        "--remesh_option", "quad"
+    ]
+    
+    logger.info(f"Running command: {' '.join(command)}")
+    print(f"Reached at subprocess.run() The output path is {output_dir}")
+    
+    try:
+        HF_CACHE_PATH = "/tmp/huggingface_cache"
+        os.makedirs(HF_CACHE_PATH, exist_ok=True)
+        env = os.environ.copy()
+        env["HF_HOME"] = "/tmp/huggingface"
+        env["TRANSFORMERS_CACHE"] = HF_CACHE_PATH
+        env["HF_HUB_CACHE"] = HF_CACHE_PATH
+        env["NUMBA_CACHE_DIR"] = "/tmp"
+
+        result = subprocess.run(
+        command,
+        cwd=repo_path,
+        check=True,
+        capture_output=True,
+        text=True,
+        env=env)  # pass updated env here
+        
+        
+        logger.info(f"Subprocess STDOUT:\n{result.stdout}")
+        logger.info(f"Subprocess STDERR:\n{result.stderr}")
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Subprocess failed with exit code {e.returncode}")
+        logger.error(f"STDOUT:\n{e.stdout}")
+        logger.error(f"STDERR:\n{e.stderr}")
+        raise Exception(f"Subprocess failed: {e.stderr}")
+    
+    # Find the generated GLB file
+    # The model typically outputs files to a subdirectory named after the input image
+    # without the file extension
+    base_name = os.path.basename(image_path)
+    file_name_without_ext = os.path.splitext(base_name)[0]
+    
+    # Look for GLB files in the output directory and its subdirectories
+    glb_files = glob.glob(os.path.join(output_dir, "**", "*.glb"), recursive=True)
+    
+    if not glb_files:
+        logger.error(f"No GLB files found in {output_dir}")
+        raise Exception("No GLB file was generated")
+    
+    logger.info(f"Found GLB file: {glb_files[0]}")
+    print(f"Returned the path {glb_files[0]}")
+    return glb_files[0]

main.py

@@ -0,0 +1,76 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Query
+from fastapi.responses import FileResponse
+import os
+import shutil
+import uuid
+import requests
+from typing import Optional
+from app.utils import run_inference
+
+from huggingface_hub import login
+
+hf_token = os.environ.get("HF_TOKEN")
+print(hf_token)
+login(token=hf_token)
+
+
+app = FastAPI(title="Stable Fast 3D API")
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to Stable Fast 3D API. Use /generate-3d endpoint to convert 2D images to 3D models."}
+
+@app.post("/generate-3d/")
+async def generate_3d_model_upload(image: UploadFile = File(...)):
+    """Generate 3D model from uploaded image file"""
+    return await process_image(image=image)
+
+@app.get("/generate-3d/")
+async def generate_3d_model_url(image_url: str = Query(..., description="URL of the image to convert to 3D")):
+    """Generate 3D model from image URL"""
+    return await process_image(image_url=image_url)
+
+async def process_image(image: Optional[UploadFile] = None, image_url: Optional[str] = None):
+    # Create unique ID for this request
+    temp_id = str(uuid.uuid4())
+    input_path = f"/app/tmp/{temp_id}.png"
+    output_dir = f"/app/tmp/{temp_id}_output"
+    os.makedirs(output_dir, exist_ok=True)
+
+    try:
+        # Handle image from upload or URL
+        if image:
+            with open(input_path, "wb") as f:
+                shutil.copyfileobj(image.file, f)
+        elif image_url:
+            response = requests.get(image_url, stream=True)
+            if response.status_code != 200:
+                raise HTTPException(status_code=400, detail="Could not download image from URL")
+                
+            with open(input_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        else:
+            raise HTTPException(status_code=400, detail="Either image file or image URL must be provided")
+
+        # Run the inference
+        glb_path = run_inference(input_path, output_dir)
+        
+        if not os.path.exists(glb_path):
+            raise HTTPException(status_code=500, detail="Failed to generate 3D model")
+            
+        # Return the GLB file
+        return FileResponse(
+            path=glb_path, 
+            media_type="model/gltf-binary", 
+            filename="model.glb",
+            headers={"Content-Disposition": f"attachment; filename=model.glb"}
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
+    
+    finally:
+        # Clean up temporary files
+        if os.path.exists(input_path):
+            os.remove(input_path)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+python-multipart==0.0.6
+requests==2.31.0
+pillow==10.0.0
+huggingface-hub==0.17.3