Update app.py

app.py

@@ -1,12 +1,12 @@
 from fastapi import FastAPI, Response
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-import torch
-from diffusers import DiffusionPipeline
 from PIL import Image
 import io
 import base64
 import re
+import numpy as np
+import cv2 # This is the OpenCV library
 
 # Pydantic model to expect two base64 strings
 class InpaintRequest(BaseModel):
@@ -23,50 +23,42 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# --- THE GUARANTEED FIX: USING STABLE DIFFUSION v1.5 INPAINTING ---
-# This model is the perfect balance of quality and performance for free hardware.
-# It's lighter than the v2 model and will not crash due to memory issues.
-print("Loading Stable Diffusion v1.5 Inpainting model...")
-pipeline = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-inpainting",
-    torch_dtype=torch.float16,
-)
-# Move to CPU
-pipeline = pipeline.to("cpu")
-# Enable memory saving for stability
-pipeline.enable_attention_slicing()
-print("Model loaded successfully!")
+# --- NO HEAVY MODEL TO LOAD! THE APP STARTS INSTANTLY. ---
+print("OpenCV Magic Eraser API is ready!")
 
-def base64_to_image(base64_string):
-    """Decodes a base64 string into a PIL Image."""
+def base64_to_cv2_image(base64_string):
+    """Decodes a base64 string into an OpenCV image (numpy array)."""
     base64_data = re.sub('^data:image/.+;base64,', '', base64_string)
     img_data = base64.b64decode(base64_data)
-    return Image.open(io.BytesIO(img_data)).convert("RGB")
+    np_arr = np.frombuffer(img_data, np.uint8)
+    # cv2.imdecode reads an image from the buffer
+    return cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
 
 @app.post("/inpaint")
 async def inpaint_image(request: InpaintRequest):
     try:
-        init_image = base64_to_image(request.image_data)
-        mask_image = base64_to_image(request.mask_data)
+        # 1. Decode base64 strings into OpenCV images
+        init_image = base64_to_cv2_image(request.image_data)
+        
+        # For the mask, we need it in grayscale
+        mask_image_color = base64_to_cv2_image(request.mask_data)
+        mask_image_gray = cv2.cvtColor(mask_image_color, cv2.COLOR_BGR2GRAY)
+        
+        # The inpainting algorithm needs a binary mask (black and white)
+        # We'll make any non-black pixel white
+        _, mask = cv2.threshold(mask_image_gray, 1, 255, cv2.THRESH_BINARY)
 
-        print("Received images for inpainting.")
+        print("Received images. Starting high-speed inpainting...")
         
-        if init_image.size != mask_image.size:
-            mask_image = mask_image.resize(init_image.size)
-            
-        # Run the inpainting pipeline
-        inpainted_image = pipeline(
-            prompt="high quality, detailed", # A generic prompt helps
-            image=init_image, 
-            mask_image=mask_image
-        ).images[0]
+        # 2. Run the high-speed OpenCV inpainting algorithm
+        # cv2.INPAINT_NS is based on Navier-Stokes, giving high-quality results
+        inpainted_image = cv2.inpaint(init_image, mask, 3, cv2.INPAINT_NS)
         
-        print("Inpainting complete.")
+        print("Inpainting complete in milliseconds.")
 
-        # Convert result back to base64
-        buffer = io.BytesIO()
-        inpainted_image.save(buffer, format="PNG")
-        img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        # 3. Convert the result back to a base64 string to send to the frontend
+        _, buffer = cv2.imencode('.png', inpainted_image)
+        img_str = base64.b64encode(buffer).decode("utf-8")
 
         return {"inpainted_image_data": img_str}
 
@@ -76,4 +68,4 @@ async def inpaint_image(request: InpaintRequest):
 
 @app.get("/")
 def read_root():
-    return {"Status": "Magic Eraser API is running!"}
+    return {"Status": "High-Speed OpenCV Magic Eraser API is running!"}