Adapted to follow the logic from the provided Django api/views.py

app.py

@@ -1,11 +1,10 @@
-# Final, Complete, and Working app.py for Hugging Face Space
+# app.py
+# Adapted to follow the logic from the provided Django api/views.py
 import os
 import cv2
 import tempfile
 import numpy as np
 import uvicorn
-import requests
-import io
 import base64
 from PIL import Image
 from inference_sdk import InferenceHTTPClient
@@ -16,8 +15,12 @@ from huggingface_hub import hf_hub_download
 import gradio as gr
 
 # --- 1. Configuration and Model Loading ---
-ROBOFLOW_API_KEY = os.environ.get("ROBOFLOW_API_KEY")
+# Constants from the new Django logic
+MAX_INFER_DIM = 1024
+ENHANCED_SIZE = (224, 224)
 
+# Roboflow and TF Model setup
+ROBOFLOW_API_KEY = os.environ.get("ROBOFLOW_API_KEY")
 CLIENT_FACE = InferenceHTTPClient(api_url="https://detect.roboflow.com", api_key=ROBOFLOW_API_KEY)
 CLIENT_EYES = InferenceHTTPClient(api_url="https://detect.roboflow.com", api_key=ROBOFLOW_API_KEY)
 CLIENT_IRIS = InferenceHTTPClient(api_url="https://detect.roboflow.com", api_key=ROBOFLOW_API_KEY)
@@ -31,177 +34,178 @@ except Exception as e:
     print(f"--- FATAL ERROR: COULD NOT LOAD LEUKOCORIA MODEL: {e} ---")
     raise RuntimeError(f"Could not load leukocoria model: {e}")
 
-# --- 2. All Helper Functions ---
+# --- 2. Helper Functions (Adapted from Django views.py) ---
 
-# NOTE: The 'enhance_image_unsharp_mask' function has been removed.
+def enhance_image_unsharp_mask(image, strength=0.5, radius=5):
+    """Enhances image using unsharp masking."""
+    blur = cv2.GaussianBlur(image, (radius, radius), 0)
+    return cv2.addWeighted(image, 1.0 + strength, blur, -strength, 0)
 
 def detect_faces_roboflow(image_path):
+    """Detects faces using Roboflow."""
     return CLIENT_FACE.infer(image_path, model_id="face-detector-v4liw/2").get("predictions", [])
 
-def detect_eyes_roboflow(image_path, raw_image):
-    """Calls Roboflow to find eyes and returns cropped images of them."""
+def detect_eyes_roboflow(image_path):
+    """
+    Detects eyes, resizing the image if necessary for inference,
+    then scales coordinates back to the original image size.
+    """
+    raw_image = cv2.imread(image_path)
+    if raw_image is None:
+        return None, []
+
+    h, w = raw_image.shape[:2]
+    scale = min(1.0, MAX_INFER_DIM / max(h, w))
+    
+    # Use a temporary file for inference if resizing is needed
+    if scale < 1.0:
+        small_image = cv2.resize(raw_image, (int(w*scale), int(h*scale)))
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
+            cv2.imwrite(tmp.name, small_image)
+            infer_path = tmp.name
+    else:
+        infer_path = image_path
+
     try:
-        resp = CLIENT_EYES.infer(image_path, model_id="eye-detection-kso3d/3")
-        crops = []
-        for p in resp.get("predictions", []):
-            x1 = int(p['x'] - p['width'] / 2)
-            y1 = int(p['y'] - p['height'] / 2)
-            x2 = int(p['x'] + p['width'] / 2)
-            y2 = int(p['y'] + p['height'] / 2)
-            crop = raw_image[y1:y2, x1:x2]
-            if crop.size > 0:
-                crops.append(crop)
-        return crops, None
-    except Exception as e:
-        print(f"Error in Roboflow eye detection: {e}")
-        return [], str(e)
+        resp = CLIENT_EYES.infer(infer_path, model_id="eye-detection-kso3d/3")
+    finally:
+        # Clean up temp file if one was created
+        if scale < 1.0 and os.path.exists(infer_path):
+            os.remove(infer_path)
+
+    crops = []
+    for p in resp.get("predictions", []):
+        # Scale coordinates back to original image dimensions
+        cx, cy = p["x"] / scale, p["y"] / scale
+        bw, bh = p["width"] / scale, p["height"] / scale
+        
+        # Crop from the original raw image
+        x1 = int(cx - bw / 2)
+        y1 = int(cy - bh / 2)
+        x2 = int(cx + bw / 2)
+        y2 = int(cy + bh / 2)
+        
+        crop = raw_image[y1:y2, x1:x2]
+        if crop.size > 0:
+            crops.append({"coords": (x1, y1, x2, y2), "image": crop})
+            
+    return raw_image, crops
 
 def get_largest_iris_prediction(eye_crop):
-    "Calls Roboflow to find the largest iris using a temporary file for reliability."
+    """Finds the largest iris in an eye crop."""
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
-        # Save the original eye crop, not an enhanced version
         cv2.imwrite(tmp.name, eye_crop)
-        temp_iris_path = tmp.name
+        temp_path = tmp.name
     try:
-        resp = CLIENT_IRIS.infer(temp_iris_path, model_id="iris_120_set/7")
+        resp = CLIENT_IRIS.infer(temp_path, model_id="iris_120_set/7")
         preds = resp.get("predictions", [])
         return max(preds, key=lambda p: p["width"] * p["height"]) if preds else None
     finally:
-        os.remove(temp_iris_path)
+        os.remove(temp_path)
 
 def run_leukocoria_prediction(iris_crop):
-    if leuko_model is None: return {"error": "Leukocoria model not loaded"}, 0.0
-    # Convert crop to PIL Image
-    img_pil = Image.fromarray(cv2.cvtColor(iris_crop, cv2.COLOR_BGR2RGB))
-    # Resize the original image array
-    img_resized = cv2.resize(np.array(img_pil), (224, 224))
-    # Normalize and expand dimensions for the model
-    img_array = np.array(img_resized) / 255.0
+    """Runs the loaded TensorFlow model on an iris crop."""
+    # The logic from views.py is now directly in the TF model call
+    enh = enhance_image_unsharp_mask(iris_crop)
+    enh_rs = cv2.resize(enh, ENHANCED_SIZE)
+    
+    img_array = np.array(enh_rs) / 255.0
     img_array = np.expand_dims(img_array, axis=0)
+    
     prediction = leuko_model.predict(img_array)
     confidence = float(prediction[0][0])
     has_leuko = confidence > 0.5
     return has_leuko, confidence
 
+def to_base64(image):
+    """Converts a CV2 image to a base64 string."""
+    _, buffer = cv2.imencode(".jpg", image)
+    return "data:image/jpeg;base64," + base64.b64encode(buffer).decode()
+
 # --- 3. FastAPI Application ---
 app = FastAPI()
 
 @app.post("/detect/")
 async def full_detection_pipeline(image: UploadFile = File(...)):
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
-        contents = await image.read()
-        tmp.write(contents)
+        tmp.write(await image.read())
         temp_image_path = tmp.name
+
     try:
-        raw_image = cv2.imread(temp_image_path)
+        # Step 1: Face Check
+        if not detect_faces_roboflow(temp_image_path):
+            return JSONResponse(status_code=200, content={"warnings": ["No face detected."]})
+
+        # Step 2: Eye Detection
+        raw_image, eye_crops = detect_eyes_roboflow(temp_image_path)
         if raw_image is None:
             return JSONResponse(status_code=400, content={"error": "Could not read uploaded image."})
-        if not detect_faces_roboflow(temp_image_path):
-            return JSONResponse(status_code=400, content={"error": "No face detected."})
-        image_to_process = raw_image
-        was_mirrored = False
-        
-        print("--- 1. Attempting detection on original image... ---")
-        eye_crops, error_msg = detect_eyes_roboflow(temp_image_path, image_to_process)
-        print(f"--- 2. Found {len(eye_crops)} eyes in original image. ---")
+
         if len(eye_crops) != 2:
-            print("--- 3. Original failed. Attempting detection on mirrored image... ---")
-            mirrored_image = cv2.flip(raw_image, 1)
-            image_to_process = mirrored_image
-            was_mirrored = True
-            
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp_mirrored:
-                cv2.imwrite(tmp_mirrored.name, mirrored_image)
-                temp_mirrored_image_path = tmp_mirrored.name
-            try:
-                eye_crops, error_msg = detect_eyes_roboflow(temp_mirrored_image_path, image_to_process)
-                print(f"--- 4. Found {len(eye_crops)} eyes in mirrored image. ---")
-            finally:
-                os.remove(temp_mirrored_image_path)
-        
-        if error_msg or len(eye_crops) != 2:
-            return JSONResponse(
-                status_code=400,
-                content={"error": "Could not detect exactly two eyes. Please try another photo."}
-            )
-        
-        initial_boxes = [cv2.boundingRect(cv2.cvtColor(c, cv2.COLOR_BGR2GRAY)) for c in eye_crops]
-        print(f"--- 5. Initial eye coordinates (x,y,w,h): {initial_boxes} ---")
-        
-        eye_crops.sort(key=lambda c: cv2.boundingRect(cv2.cvtColor(c, cv2.COLOR_BGR2GRAY))[0])
-        
-        sorted_boxes = [cv2.boundingRect(cv2.cvtColor(c, cv2.COLOR_BGR2GRAY)) for c in eye_crops]
-        print(f"--- 6. Sorted eye coordinates (x,y,w,h): {sorted_boxes} ---")
-        
-        if was_mirrored:
-            print("--- 7. Image was mirrored, reversing eye order for correct labeling. ---")
-            eye_crops.reverse()
-            reversed_boxes = [cv2.boundingRect(cv2.cvtColor(c, cv2.COLOR_BGR2GRAY)) for c in eye_crops]
-            print(f"--- 8. Reversed eye coordinates (x,y,w,h): {reversed_boxes} ---")
-        
+            return JSONResponse(status_code=200, content={
+                "analyzed_image": to_base64(raw_image),
+                "warnings": ["Exactly two eyes not detected."]
+            })
+
+        # Step 3: Process Eyes with NEW Labeling Logic
+        sorted_eyes = sorted(eye_crops, key=lambda e: e["coords"][0])
+        images_b64 = {}
         flags = {}
-        eye_images_b64 = {}
-        for i, eye_crop in enumerate(eye_crops):
-            side = "right" if i == 0 else "left"
-            print(f"--- 9. Processing loop index {i}, assigning to: {side} eye. ---")
-            
-            is_success, buffer = cv2.imencode(".jpg", eye_crop)
-            if is_success:
-                eye_images_b64[side] = "data:image/jpeg;base64," + base64.b64encode(buffer).decode("utf-8")
+        
+        # This new loop labels the left-most eye as "left" and right-most as "right"
+        for side, eye_info in zip(("left", "right"), sorted_eyes):
+            eye_img = eye_info["image"]
             
-            pred = get_largest_iris_prediction(eye_crop)
+            # Iris detection and Leukocoria prediction
+            pred = get_largest_iris_prediction(eye_img)
             if pred:
-                x1, y1 = int(pred['x'] - pred['width'] / 2), int(pred['y'] - pred['height'] / 2)
-                x2, y2 = int(pred['x'] + pred['width'] / 2), int(pred['y'] + pred['height'] / 2)
-                iris_crop = eye_crop[y1:y2, x1:x2]
+                cx, cy, w, h = pred["x"], pred["y"], pred["width"], pred["height"]
+                x1, y1 = int(cx - w / 2), int(cy - h / 2)
+                x2, y2 = int(cx + w / 2), int(cy + h / 2)
+                
+                iris_crop = eye_img[y1:y2, x1:x2]
+                
                 has_leuko, confidence = run_leukocoria_prediction(iris_crop)
                 flags[side] = has_leuko
             else:
                 flags[side] = None
-                
-        print("--- 10. Final generated flags:", flags, "---")
-        
-        is_success_main, buffer_main = cv2.imencode(".jpg", image_to_process)
-        analyzed_image_b64 = ""
-        if is_success_main:
-            analyzed_image_b64 = "data:image/jpeg;base64," + base64.b64encode(buffer_main).decode("utf-8")
-            
-        return JSONResponse(content={
+
+            images_b64[side] = to_base64(eye_img)
+
+        # Step 4: Prepare and return the final response
+        return JSONResponse(status_code=200, content={
+            "analyzed_image": to_base64(raw_image),
+            "two_eyes": images_b64,
             "leukocoria": flags,
-            "warnings": [],
-            "two_eyes": eye_images_b64,
-            "analyzed_image": analyzed_image_b64
+            "warnings": []
         })
+
     finally:
         os.remove(temp_image_path)
 
-# --- 4. Create and Mount the Gradio UI ---
+# --- 4. Gradio UI (for simple testing) ---
 def gradio_wrapper(image_array):
-    """A wrapper function to call our own FastAPI endpoint from the Gradio UI."""
     try:
         pil_image = Image.fromarray(image_array)
         with io.BytesIO() as buffer:
             pil_image.save(buffer, format="JPEG")
             files = {'image': ('image.jpg', buffer.getvalue(), 'image/jpeg')}
-            # The URL points to the local FastAPI server running within the Hugging Face Space
             response = requests.post("http://127.0.0.1:7860/detect/", files=files)
             
-        if response.status_code == 200:
-            return response.json()
-        else:
-            return {"error": f"API Error {response.status_code}", "details": response.text}
+        return response.json()
     except Exception as e:
         return {"error": str(e)}
 
 gradio_ui = gr.Interface(
     fn=gradio_wrapper,
-    inputs=gr.Image(type="numpy", label="Upload an eye image to test the full pipeline"),
+    inputs=gr.Image(type="numpy", label="Upload an eye image"),
     outputs=gr.JSON(label="Analysis Results"),
     title="LeukoLook Eye Detector",
-    description="A demonstration of the LeukoLook detection model pipeline.")
+    description="Demonstration of the full detection pipeline."
+)
 
 app = gr.mount_gradio_app(app, gradio_ui, path="/")
 
-# --- 5. Run the server ---
+# --- 5. Run Server ---
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)