initial

Dockerfile

@@ -0,0 +1,28 @@
+# Use python 3.10
+FROM python:3.10
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies for OpenCV (required even for headless version)
+RUN apt-get update && apt-get install -y libgl1-mesa-glx libglib2.0-0
+
+# Create a folder for models so we have permission to write to it
+RUN mkdir -p /app/models && chmod 777 /app/models
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the downloader script
+COPY download_model.py .
+
+# --- BUILD STEP: DOWNLOAD MODEL ---
+# This runs during the build process. The large file becomes part of the Docker image.
+RUN python download_model.py
+
+# Copy the rest of the application
+COPY . .
+
+# Start the server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,67 @@
+from fastapi import FastAPI, UploadFile, File, Response
+from cellpose import models, io
+import numpy as np
+import cv2
+import io as sys_io
+import os
+import tifffile
+
+# 1. Point Cellpose to the folder where we downloaded the model in the Dockerfile
+os.environ["CELLPOSE_LOCAL_MODELS_PATH"] = "/app/models"
+
+app = FastAPI()
+
+# 2. Load the model globally (once) on startup
+# It will find the file in /app/models, so it won't download again.
+print("Loading Cellpose-SAM...")
+model = models.CellposeModel(model_type='cpsam', gpu=False)
+print("Cellpose-SAM Ready!")
+
+@app.post("/segment")
+async def segment(
+    image: UploadFile = File(...),
+    diameter: float = 0.0,
+    flow_threshold: float = 0.4,
+    cellprob_threshold: float = 0.0,
+    channels: str = "0,0"  # Expecting "0,0" or "2,3" string
+):
+    try:
+        # --- PARSE INPUT ---
+        print(f"Received image: {image.filename}")
+        
+        # Parse channels string "2,1" -> [2, 1]
+        chan_list = [int(c) for c in channels.split(',')]
+        
+        # Read image bytes
+        contents = await image.read()
+        nparr = np.frombuffer(contents, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)
+
+        # Handle different image depths/formats if necessary
+        if img is None:
+            return Response(content="Could not decode image", status_code=400)
+
+        # --- INFERENCE ---
+        # diameter=0 runs auto-estimation
+        masks, flows, styles = model.eval(
+            img, 
+            diameter=diameter if diameter > 0 else None,
+            channels=chan_list,
+            flow_threshold=flow_threshold,
+            cellprob_threshold=cellprob_threshold
+        )
+
+        # --- FORMAT OUTPUT ---
+        # We return the MASKS as a TIFF file (16-bit to support >255 cells)
+        masks = masks.astype(np.uint16)
+        
+        # Write to memory buffer
+        with sys_io.BytesIO() as buf:
+            tifffile.imwrite(buf, masks)
+            response_bytes = buf.getvalue()
+
+        return Response(content=response_bytes, media_type="image/tiff")
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return Response(content=str(e), status_code=500)

download_model.py

@@ -0,0 +1,10 @@
+from cellpose import models
+import os
+
+# Set the cache path to a fixed location inside the container
+os.environ["CELLPOSE_LOCAL_MODELS_PATH"] = "/app/models"
+
+print("⏳ Downloading Cellpose-SAM model (1.2GB)... this may take a few minutes...")
+# Initializing the model triggers the download
+models.CellposeModel(model_type='cpsam', gpu=False)
+print("✅ Model downloaded and cached to /app/models!")

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+python-multipart
+numpy
+cellpose
+torch
+opencv-python-headless
+imagecodecs
+tifffile