add gradio interface with preprocessing and model prediction

app.py

@@ -1,27 +1,65 @@
 import gradio as gr
 import tensorflow as tf
+import numpy as np
+import cv2
 from huggingface_hub import hf_hub_download
+from tensorflow.keras.preprocessing import image
 
-def check_model():
-    try:
-        # 📥 descargamos el archivo simpleNet.h5 desde el repo del modelo
-        model_path = hf_hub_download(repo_id="Martinagg/simpleNet", filename="simpleNet.h5")
-        
-        # 🔄 cargamos el modelo
-        model = tf.keras.models.load_model(model_path)
-        
-        return "✅ Modelo cargado correctamente desde Hugging Face"
-    except Exception as e:
-        return f"❌ Error cargando modelo: {str(e)}"
-
-# 🎛️ Interfaz Gradio simple (solo un botón)
+# === Importar funciones del pipeline ===
+from src.preprocessing.zoom import apply_zoom
+from src.preprocessing.hair_removal import quitar_pelos
+from src.preprocessing.segmentation import segmentar_lesion
+
+# Tamaño de entrada del modelo
+ROWS, COLS = 224, 224
+
+# === Cargar modelo desde Hugging Face Hub ===
+model_path = hf_hub_download(repo_id="Martinagg/simpleNet", filename="simpleNet.h5")
+model = tf.keras.models.load_model(model_path)
+
+# === Función de predicción ===
+def preprocess_and_predict(img_input):
+    # Convertir PIL a OpenCV (BGR)
+    img = np.array(img_input)[:, :, ::-1]
+
+    # 1. Zoom
+    zoomed = apply_zoom(img, zoom_factor=0.9)
+
+    # 2. Quitar pelos
+    rgb_clean = cv2.cvtColor(zoomed, cv2.COLOR_BGR2RGB)
+    clean = quitar_pelos(rgb_clean)
+
+    # 3. Segmentar (obtienes máscara y lesión recortada)
+    mask, lesion_rgb = segmentar_lesion(clean, size=(ROWS, COLS))
+
+    # 4. Preparar la imagen segmentada para el modelo
+    lesion_resized = cv2.resize(lesion_rgb, (ROWS, COLS))
+    img_array = image.img_to_array(lesion_resized) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)  # batch dimension
+
+    # 5. Predicción
+    probs = model.predict(img_array)[0]
+    classes = ["Benign", "Malignant"]
+    pred_idx = np.argmax(probs)
+    pred_label = classes[pred_idx]
+
+    result_text = f"Predicción: {pred_label} ({probs[pred_idx]*100:.2f}%)"
+
+    return mask, lesion_rgb, result_text
+
+# === Interfaz Gradio ===
 demo = gr.Interface(
-    fn=check_model,
-    inputs=None,
-    outputs="text",
-    title="Prueba de carga - simpleNet",
-    description="Este Space solo verifica que el modelo simpleNet se carga desde Hugging Face."
+    fn=preprocess_and_predict,
+    inputs=gr.Image(type="pil", label="Sube una imagen de lesión"),
+    outputs=[
+        gr.Image(type="numpy", label="Máscara Binaria"),
+        gr.Image(type="numpy", label="Lesión Segmentada"),
+        gr.Textbox(label="Resultado del Modelo")
+    ],
+    title="DermaScan - Clasificación de Lesiones",
+    description="Sube una imagen de piel. El sistema segmenta la lesión, muestra la máscara y la predicción (benigno vs maligno)."
 )
 
 if __name__ == "__main__":
     demo.launch()
+

preprocessing/hair_removal.py

@@ -0,0 +1,13 @@
+import cv2
+import numpy as np
+
+def quitar_pelos(rgb):
+    """Elimina pelos de una imagen RGB usando black-hat + inpaint."""
+    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 9))
+    blackhat = cv2.morphologyEx(gray, cv2.MORPH_BLACKHAT, kernel)
+    
+    _, hair_mask = cv2.threshold(blackhat, 10, 255, cv2.THRESH_BINARY)
+    rgb_clean = cv2.inpaint(rgb, hair_mask, 3, cv2.INPAINT_TELEA)
+    
+    return rgb_clean

preprocessing/metrics.py

@@ -0,0 +1,111 @@
+import cv2
+import numpy as np
+import math
+
+def _leer_mask(mask):
+    """Lee una máscara que puede venir como ruta o como array."""
+    if isinstance(mask, str):  # si es ruta
+        mask = cv2.imread(mask, cv2.IMREAD_GRAYSCALE)
+    elif mask.ndim == 3:  # si es RGB/BGR
+        mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
+
+    if mask is None:
+        raise ValueError("No se pudo leer la máscara.")
+    return mask
+
+
+def calcular_area(mask):
+    mask = _leer_mask(mask)
+    _, mask_bin = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(mask_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return 0.0
+    cnt = max(contours, key=cv2.contourArea)
+    area = cv2.contourArea(cnt)
+    if not np.isfinite(area):
+        area = 0.0
+    return round(float(area), 2)
+
+
+def calcular_perimetro(mask):
+    mask = _leer_mask(mask)
+    _, mask_bin = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(mask_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return 0.0
+    cnt = max(contours, key=cv2.contourArea)
+    perimetro = cv2.arcLength(cnt, True)
+    if not np.isfinite(perimetro):
+        perimetro = 0.0
+    return round(float(perimetro), 2)
+
+
+def calcular_circularidad(mask):
+    mask = _leer_mask(mask)
+    _, mask_bin = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(mask_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    if not contours:
+        return 0.0
+
+    cnt = max(contours, key=cv2.contourArea)
+    area = cv2.contourArea(cnt)
+    perimetro = cv2.arcLength(cnt, True)
+
+    if perimetro == 0 or area == 0:
+        return 0.0
+
+    circ = (4 * math.pi * area) / (perimetro ** 2)
+
+    if not np.isfinite(circ):
+        circ = 0.0
+
+    circ = np.clip(circ, 0, 1)
+    return round(float(circ), 4)
+
+
+def calcular_simetria(mask):
+    mask = _leer_mask(mask)
+    _, mask_bin = cv2.threshold(mask, 127, 1, cv2.THRESH_BINARY)
+
+    if np.sum(mask_bin) == 0:
+        return 0.0, 0.0
+
+    y, x = np.where(mask_bin > 0)
+    y_min, y_max = y.min(), y.max()
+    x_min, x_max = x.min(), x.max()
+    roi = mask_bin[y_min:y_max+1, x_min:x_max+1]
+
+    h, w = roi.shape
+    size = max(h, w)
+    canvas = np.zeros((size, size), dtype=np.uint8)
+    y_off, x_off = (size - h)//2, (size - w)//2
+    canvas[y_off:y_off+h, x_off:x_off+w] = roi
+    mask_centered = canvas
+
+    cy, cx = np.mean(np.column_stack(np.where(mask_centered > 0)), axis=0).astype(int)
+    area_total = np.sum(mask_centered)
+
+    if area_total == 0:
+        return 0.0, 0.0
+
+    # --- simetría vertical ---
+    left = mask_centered[:, :cx]
+    right = mask_centered[:, cx:]
+    right_flipped = np.fliplr(right)
+    min_width = min(left.shape[1], right_flipped.shape[1])
+    xor_v = np.logical_xor(left[:, :min_width], right_flipped[:, :min_width])
+    sim_v = 1 - (np.sum(xor_v) / area_total)
+
+    # --- simetría horizontal ---
+    top = mask_centered[:cy, :]
+    bottom = mask_centered[cy:, :]
+    bottom_flipped = np.flipud(bottom)
+    min_height = min(top.shape[0], bottom_flipped.shape[0])
+    xor_h = np.logical_xor(top[:min_height, :], bottom_flipped[:min_height, :])
+    sim_h = 1 - (np.sum(xor_h) / area_total)
+
+    sim_v = max(0.0, min(1.0, sim_v))
+    sim_h = max(0.0, min(1.0, sim_h))
+
+    return round(sim_v, 3), round(sim_h, 3)

preprocessing/segmentation.py

@@ -0,0 +1,48 @@
+import cv2
+import numpy as np
+
+def segmentar_lesion(rgb, size=(224, 224)):
+
+    # Redimensionar y convertir a HSV
+    rgb = cv2.resize(rgb, size)
+    hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV)
+    S = hsv[:, :, 1]
+    S_blur = cv2.GaussianBlur(S, (5, 5), 0)
+
+    # Umbralización con Otsu
+    _, mask = cv2.threshold(S_blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+    # Selección de la región más grande y centrada
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask)
+    h, w = mask.shape
+    center = np.array([w / 2, h / 2])
+
+    valid_regions = []
+    for i in range(1, num_labels):
+        area = stats[i, cv2.CC_STAT_AREA]
+        cX, cY = centroids[i]
+        dist = np.linalg.norm(np.array([cX, cY]) - center)
+        if dist < min(w, h) / 3:
+            valid_regions.append((i, area, dist))
+
+    if len(valid_regions) == 0:
+        largest_label = 1 + np.argmax(stats[1:, cv2.CC_STAT_AREA])
+    else:
+        largest_label = max(valid_regions, key=lambda x: x[1])[0]
+
+    largest_mask = np.zeros_like(mask)
+    largest_mask[labels == largest_label] = 255
+
+    # Rellenar huecos internos
+    inv = cv2.bitwise_not(largest_mask)
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(inv)
+    for i in range(1, num_labels):
+        x, y, w_box, h_box, area = stats[i]
+        if x > 0 and y > 0 and (x + w_box) < w and (y + h_box) < h:
+            inv[labels == i] = 0
+    filled_mask = cv2.bitwise_not(inv)
+
+    #  Aplicar la máscara al RGB limpio
+    lesion_rgb = cv2.bitwise_and(rgb, rgb, mask=filled_mask)
+
+    return filled_mask, lesion_rgb

preprocessing/zoom.py

@@ -0,0 +1,13 @@
+import cv2
+
+def apply_zoom(image, zoom_factor=0.9):
+    """Aplica un zoom centrado a la imagen."""
+    h, w = image.shape[:2]
+    new_h, new_w = int(h * zoom_factor), int(w * zoom_factor)
+    
+    top = (h - new_h) // 2
+    left = (w - new_w) // 2
+    
+    cropped = image[top:top+new_h, left:left+new_w]
+    zoomed = cv2.resize(cropped, (w, h))
+    return zoomed

requirements.txt

@@ -2,3 +2,6 @@ gradio
 tensorflow
 huggingface_hub
 numpy
+opencv-python-headless
+pandas
+tqdm