Patch Space for WoundDoc mobile app API integration

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+# Install system dependencies for OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code/
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Woundsized
-emoji: ⚡
-colorFrom: yellow
-colorTo: green
+title: Wound Size Analysis
+emoji: 📏
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,191 @@
+import base64
+import io
+import os
+import re
+import uuid
+from typing import Any, Dict
+
+import cv2
+import gradio as gr
+import numpy as np
+import tensorflow as tf
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
+from PIL import Image
+from pydantic import BaseModel
+
+# --- CONFIGURATION ---
+MODEL_PATH = "wound_segmentation_model.h5"
+IMG_HEIGHT = 256
+IMG_WIDTH = 256
+
+# --- ARUCO SETTINGS ---
+ARUCO_DICT_TYPE = cv2.aruco.DICT_4X4_50
+MARKER_SIZE_CM = 2.0  # Assumes a 2x2 cm marker
+
+# --- LEGACY FALLBACK SETTINGS ---
+LOWER_BLUE = np.array([95, 60, 100])
+UPPER_BLUE = np.array([120, 255, 255])
+
+TISSUE_TYPES = [
+    {'name': 'Eschar / Necrotic Tissue', 'display_name': 'eschar_necrotic', 'id': 1, 'color': (128, 128, 128), 'lower': np.array([0, 0, 0]), 'upper': np.array([179, 255, 67])},
+    {'name': 'Healthy Granulation Tissue', 'display_name': 'healthy_granulation', 'id': 5, 'color': (0, 0, 255), 'lower': np.array([0, 205, 100]), 'upper': np.array([10, 255, 200])},
+    {'name': 'Infected / Pseudomonas', 'display_name': 'infected', 'id': 11, 'color': (0, 255, 0), 'lower': np.array([20, 105, 0]), 'upper': np.array([40, 205, 150])},
+    {'name': 'Slough / Fibrinous', 'display_name': 'slough', 'id': 25, 'color': (255, 255, 0), 'lower': np.array([50, 55, 150]), 'upper': np.array([70, 155, 255])},
+    {'name': 'Epithelializing Tissue', 'display_name': 'epithelializing', 'id': 29, 'color': (255, 0, 255), 'lower': np.array([140, 1, 203]), 'upper': np.array([160, 101, 255])},
+]
+
+# --- HELPERS ---
+def iou(y_true, y_pred, smooth=1e-6):
+    y_true_f = tf.keras.backend.flatten(y_true)
+    y_pred_f = tf.keras.backend.flatten(y_pred)
+    intersection = tf.keras.backend.sum(y_true_f * y_pred_f)
+    union = tf.keras.backend.sum(y_true_f) + tf.keras.backend.sum(y_pred_f) - intersection
+    return (intersection + smooth) / (union + smooth)
+
+# --- MODEL LOADING ---
+try:
+    if os.path.exists(MODEL_PATH):
+        model = tf.keras.models.load_model(MODEL_PATH, custom_objects={"iou": iou})
+        print("--- Segmentation model loaded. ---")
+    else:
+        model = None
+        print(f"--- WARNING: Model not found at {MODEL_PATH} ---")
+except Exception as e:
+    model = None
+    print(f"--- ERROR: {e} ---")
+
+def calculate_wound_size_analysis(input_image_np: np.ndarray) -> Dict[str, Any]:
+    if model is None:
+        return {"status": "error", "message": "Model not loaded."}
+
+    original_img = cv2.cvtColor(input_image_np, cv2.COLOR_RGB2BGR)
+    img = cv2.resize(original_img, (IMG_WIDTH, IMG_HEIGHT))
+    img_array = np.expand_dims(img, axis=0) / 255.0
+    
+    predicted_mask = model.predict(img_array, verbose=0)[0]
+    predicted_mask_binary = (predicted_mask > 0.5).astype(np.uint8) * 255
+    predicted_mask_resized = cv2.resize(
+        predicted_mask_binary,
+        (original_img.shape[1], original_img.shape[0]),
+    )
+
+    if cv2.countNonZero(predicted_mask_resized) == 0:
+        return {"status": "error", "message": "No wound detected."}
+
+    total_area_cm2 = 0.0
+    ref_contour = None
+    applied_perspective = False
+    
+    # 1. ARUCO DETECTION
+    try:
+        dictionary = cv2.aruco.getPredefinedDictionary(ARUCO_DICT_TYPE)
+        parameters = cv2.aruco.DetectorParameters()
+        detector = cv2.aruco.ArucoDetector(dictionary, parameters)
+        corners, ids, _ = detector.detectMarkers(original_img)
+
+        if ids is not None and len(ids) > 0:
+            src_pts = corners[0][0].astype(np.float32)
+            side = 100.0
+            dst_pts = np.array([[0,0],[side,0],[side,side],[0,side]], dtype=np.float32)
+            M = cv2.getPerspectiveTransform(src_pts, dst_pts)
+            warped_mask = cv2.warpPerspective(predicted_mask_resized, M, (1000, 1000))
+            
+            pixel_width_cm = MARKER_SIZE_CM / side
+            pixels_per_cm2 = (1.0 / pixel_width_cm) ** 2
+            total_area_cm2 = float(cv2.countNonZero(warped_mask) / pixels_per_cm2)
+            applied_perspective = True
+            ref_contour = src_pts.astype(np.int32).reshape((-1, 1, 2))
+    except Exception as e:
+        print(f"ArUco error: {e}")
+
+    # 2. BLUE SQUARE FALLBACK
+    if not applied_perspective:
+        try:
+            hsv = cv2.cvtColor(cv2.GaussianBlur(original_img, (5,5), 0), cv2.COLOR_BGR2HSV)
+            blue_mask = cv2.inRange(hsv, LOWER_BLUE, UPPER_BLUE)
+            blue_mask = cv2.morphologyEx(blue_mask, cv2.MORPH_OPEN, np.ones((5,5)))
+            contours, _ = cv2.findContours(blue_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if contours:
+                ref_contour = max(contours, key=cv2.contourArea)
+                pixels_per_cm2 = cv2.contourArea(ref_contour) / 4.0
+                total_area_cm2 = float(cv2.countNonZero(predicted_mask_resized) / pixels_per_cm2)
+        except Exception as e:
+            print(f"Fallback error: {e}")
+
+    # 3. TISSUE SECTION ANALYSIS
+    overlay_img = original_img.copy()
+    wound_only_img = cv2.bitwise_and(original_img, original_img, mask=predicted_mask_resized)
+    hsv_wound = cv2.cvtColor(wound_only_img, cv2.COLOR_BGR2HSV)
+    
+    tissue_areas = {}
+    total_wound_pixels = cv2.countNonZero(predicted_mask_resized)
+
+    for tissue in TISSUE_TYPES:
+        color_mask = cv2.inRange(hsv_wound, tissue["lower"], tissue["upper"])
+        tissue_mask = cv2.bitwise_and(color_mask, color_mask, mask=predicted_mask_resized)
+        
+        pixel_count = cv2.countNonZero(tissue_mask)
+        percentage = (pixel_count / total_wound_pixels) if total_wound_pixels > 0 else 0
+        
+        # Calculate absolute area
+        area_cm2 = round(total_area_cm2 * percentage, 3)
+        if area_cm2 > 0:
+            tissue_areas[tissue['name']] = {
+                "area_cm2": area_cm2,
+                "percentage": round(percentage * 100, 1)
+            }
+            
+            # Draw for overlay
+            cnts, _ = cv2.findContours(tissue_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            cv2.drawContours(overlay_img, cnts, -1, tissue["color"], 2)
+
+    # 4. FINAL OVERLAY
+    if ref_contour is not None:
+        color = (0, 0, 255) if applied_perspective else (0, 255, 0)
+        cv2.drawContours(overlay_img, [ref_contour], -1, color, 3)
+    
+    final_rgb = cv2.cvtColor(overlay_img, cv2.COLOR_BGR2RGB)
+    
+    return {
+        "status": "success",
+        "total_area_cm2": round(total_area_cm2, 2),
+        "measurement_method": "ArUco (Perspective Corrected)" if applied_perspective else "Blue Square Fallback",
+        "tissue_sections": tissue_areas,
+        "overlay": final_rgb
+    }
+
+def gradio_fn(img):
+    if img is None: return None, "Please upload an image."
+    res = calculate_wound_size_analysis(img)
+    if res["status"] == "error": return None, res["message"]
+    
+    sections_text = f"### Total Wound Area: {res['total_area_cm2']} cm²\n"
+    sections_text += f"**Method:** {res['measurement_method']}\n\n"
+    sections_text += "| Tissue Type | Area (cm²) | Percentage |\n| :--- | :--- | :--- |\n"
+    for name, data in res["tissue_sections"].items():
+        sections_text += f"| {name} | {data['area_cm2']} | {data['percentage']}% |\n"
+        
+    return res["overlay"], sections_text
+
+# Create Gradio Interface
+demo = gr.Interface(
+    fn=gradio_fn,
+    inputs=gr.Image(label="Upload Wound Image with ArUco Marker"),
+    outputs=[
+        gr.Image(label="Analysis Overlay"),
+        gr.Markdown(label="Size & Section Report")
+    ],
+    title="Wound Size & Section Analyzer",
+    description="Upload a photo with a 2x2cm ArUco marker (DICT_4X4_50). The tool will correct perspective and calculate absolute areas for each wound section."
+)
+
+# Initialize FastAPI and Mount Gradio
+app = FastAPI()
+demo.queue()
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,9 @@
+gradio==4.44.1
+fastapi>=0.110.0
+pydantic>=2.0.0
+opencv-python-headless>=4.8.0.76
+numpy<2
+Pillow
+tensorflow==2.15.0
+uvicorn
+huggingface_hub==0.23.5

wound_segmentation_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79aaba3bd74139da9b53a11a81854f21cc32f5e63884abaa194867270e974cfa
+size 2998256