Update app.py

app.py

@@ -1,4 +1,4 @@
-# Contador de larvas – versión sensible (v5)
+# Contador de larvas – versión alineada a 2047x1148
 # Autor: Cesarria & ChatGPT
 
 import gradio as gr
@@ -6,119 +6,133 @@ import cv2
 import numpy as np
 import statistics
 
-# --- CONFIG GLOBAL ---
+# --- CONFIG ---
 IMG_W = 2047
 IMG_H = 1148
-BORDER_CROP = 6
+BORDER = 6   # recorte de marco
 global_count = 0
 median_single_area = None
 
-# --- PREPROCESAMIENTO ---
-def preprocess_gray_from_bgr(img_bgr):
+
+# =============== helpers ===============
+def ellipse_ratio(cnt):
+    """Relación eje menor / eje mayor de la elipse (0..1)."""
+    if len(cnt) < 5:
+        return None
+    (_, _), (MA, ma), _ = cv2.fitEllipse(cnt)
+    return min(MA, ma) / max(MA, ma)
+
+
+def contour_solidity(cnt):
+    """Solidez = área / área del hull. Sirve para descartar harina 'desflecada'."""
+    area = cv2.contourArea(cnt)
+    if area <= 0:
+        return 0.0
+    hull = cv2.convexHull(cnt)
+    hull_area = cv2.contourArea(hull)
+    if hull_area == 0:
+        return 0.0
+    return float(area) / float(hull_area)
+
+
+def preprocess(image_bgr):
     """
-    Prepara la imagen:
-    - Asegura tamaño 2047x1148
-    - Recorta bordes
-    - Pasa a gris, aplica CLAHE fuerte
-    - Quita gradiente leve (blur 15)
-    - Filtro mediano final
+    - redimensiona a 2047x1148
+    - recorta bordes
+    - pasa a gris
+    - CLAHE
+    - resta de fondo
+    - normaliza
     """
-    h, w = img_bgr.shape[:2]
-    if (w, h) != (IMG_W, IMG_H):
-        img_bgr = cv2.resize(img_bgr, (IMG_W, IMG_H), interpolation=cv2.INTER_LINEAR)
-        h, w = IMG_H, IMG_W
+    img = cv2.resize(image_bgr, (IMG_W, IMG_H), interpolation=cv2.INTER_LINEAR)
 
-    # Recorte de marco
-    y1, y2 = BORDER_CROP, h - BORDER_CROP
-    x1, x2 = BORDER_CROP, w - BORDER_CROP
-    img_crop = img_bgr[y1:y2, x1:x2]
+    # recorte
+    roi = img[BORDER:IMG_H - BORDER, BORDER:IMG_W - BORDER]
 
-    gray = cv2.cvtColor(img_crop, cv2.COLOR_BGR2GRAY)
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
 
-    # Aumentar contraste local
-    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    # realzar los puntitos blancos
+    clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8, 8))
     gray = clahe.apply(gray)
 
-    # Quitar gradiente (blur leve)
-    bg = cv2.GaussianBlur(gray, (15, 15), 0)
+    # quitar gradiente
+    bg = cv2.GaussianBlur(gray, (25, 25), 0)
     sub = cv2.subtract(gray, bg)
 
-    # Filtro mediano para reducir harina
-    sub = cv2.medianBlur(sub, 3)
-    return sub, (x1, y1)
-
-
-def binarize(img, thresh_value):
-    """Threshold fijo o Otsu (si thresh_value=0)."""
-    if thresh_value == 0:
-        _, th = cv2.threshold(img, 0, 255,
-                              cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-    else:
-        _, th = cv2.threshold(img, thresh_value, 255, cv2.THRESH_BINARY)
-    return th
+    # normalizar
+    sub = cv2.normalize(sub, None, 0, 255, cv2.NORM_MINMAX)
 
+    # pequeño blur para bajar granitos de harina
+    sub = cv2.medianBlur(sub, 3)
 
-def clean_mask(mask):
-    """Elimina ruido y une fragmentos."""
-    kernel = np.ones((3, 3), np.uint8)
-    cleaned = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
-    cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, kernel, iterations=1)
-    return cleaned
+    return sub, img  # devolvemos también la imagen redimensionada completa
 
 
-# --- DETECCIÓN ---
-def detect_larvas(image,
+def detect_larvas(image_bgr,
                   thresh_value=10,
-                  min_area=4,
-                  max_area_single=38,
-                  shape_min=0.3,
-                  shape_max=1.0):
-    """Cuenta larvas usando preprocesamiento mejorado."""
+                  min_area=6,
+                  max_area_single=40,
+                  shape_min=0.55,
+                  shape_max=0.95,
+                  min_solidity=0.7):
+    """
+    Detecta y cuenta larvas.
+    - trabaja SIEMPRE en 2047x1148
+    - filtra por área, forma y solidez
+    """
     global median_single_area
 
-    gray_proc, (x_off, y_off) = preprocess_gray_from_bgr(image)
-    th = binarize(gray_proc, int(thresh_value))
-    mask = clean_mask(th)
+    gray_proc, base_img = preprocess(image_bgr)  # base_img ya es 2047x1148
+    h_proc, w_proc = gray_proc.shape[:1][0], gray_proc.shape[:1][0]
+
+    # umbral
+    if thresh_value == 0:
+        _, th = cv2.threshold(gray_proc, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    else:
+        _, th = cv2.threshold(gray_proc, int(thresh_value), 255, cv2.THRESH_BINARY)
 
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # limpiar un poco
+    kernel = np.ones((3, 3), np.uint8)
+    th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel, iterations=1)
 
-    if len(contours) == 0 and thresh_value > 0:
-        # si no detectó nada, baja umbral automáticamente
-        _, th2 = cv2.threshold(gray_proc, int(thresh_value * 0.7), 255, cv2.THRESH_BINARY)
-        mask = clean_mask(th2)
-        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # contornos en la imagen recortada
+    contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
     good = []
     areas_all = []
-    areas_small = []
+    areas_single = []
 
     for c in contours:
         area = cv2.contourArea(c)
-        if area < min_area:
+        if area < min_area or area > 5000:
             continue
-        if area > 5000:
+
+        # forma (descartar harina despareja)
+        ratio = ellipse_ratio(c)
+        if ratio is None or not (shape_min <= ratio <= shape_max):
             continue
 
-        # Chequeo de forma
-        if len(c) >= 5:
-            (_, _), (MA, ma), _ = cv2.fitEllipse(c)
-            ratio = min(MA, ma) / max(MA, ma)
-        else:
-            ratio = 1
-        if not (shape_min <= ratio <= shape_max):
+        # solidez (descarta cosas con bordes poco definidos)
+        sol = contour_solidity(c)
+        if sol < min_solidity:
             continue
 
         good.append(c)
         areas_all.append(area)
         if area <= max_area_single:
-            areas_small.append(area)
+            areas_single.append(area)
 
-    if areas_small:
-        median_single_area = statistics.median_low(areas_small)
+    # estimar área típica
+    if areas_single:
+        median_single_area = statistics.median_low(areas_single)
     elif areas_all:
         median_single_area = statistics.median_low(areas_all)
     else:
-        return image, 0
+        # no detectamos nada
+        out = base_img.copy()
+        cv2.putText(out, "LARVAS: 0", (40, 80),
+                    cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 3)
+        return out, 0
 
     total = 0
     for c in good:
@@ -126,33 +140,39 @@ def detect_larvas(image,
         if a <= max_area_single:
             total += 1
         else:
-            estimated = int(round(a / median_single_area))
-            total += max(1, estimated)
+            est = int(round(a / median_single_area))
+            total += max(1, est)
 
-    out = image.copy()
+    # dibujar sobre la imagen COMPLETA (ya 2047x1148)
+    out = base_img.copy()
     for c in good:
-        c_shifted = c + np.array([[x_off, y_off]])
+        # como trabajamos sobre la imagen recortada, hay que desplazar
+        c_shifted = c + np.array([[BORDER, BORDER]])
         cv2.drawContours(out, [c_shifted], -1, (0, 255, 0), 1)
-    cv2.putText(out, f"LARVAS: {total}",
-                (40, 80), cv2.FONT_HERSHEY_SIMPLEX, 2,
-                (0, 0, 255), 3)
+
+    cv2.putText(out, f"LARVAS: {total}", (40, 80),
+                cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 3)
+
     return out, total
 
 
-# --- GRADIO ---
+# =============== gradio wrappers ===============
 def process(image, thresh, min_a, max_a):
     global global_count
     if image is None:
         return None, "No subiste imagen", f"Conteo total: {global_count}"
 
     img_bgr = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-    proc, n = detect_larvas(img_bgr,
-                            thresh_value=int(thresh),
-                            min_area=int(min_a),
-                            max_area_single=int(max_a))
+
+    out_img_bgr, n = detect_larvas(
+        img_bgr,
+        thresh_value=int(thresh),
+        min_area=int(min_a),
+        max_area_single=int(max_a)
+    )
     global_count += n
-    img_rgb = cv2.cvtColor(proc, cv2.COLOR_BGR2RGB)
-    return img_rgb, f"Larvas en la imagen: {n}", f"Conteo total: {global_count}"
+    out_img_rgb = cv2.cvtColor(out_img_bgr, cv2.COLOR_BGR2RGB)
+    return out_img_rgb, f"Larvas en la imagen: {n}", f"Conteo total: {global_count}"
 
 
 def reset():
@@ -161,17 +181,17 @@ def reset():
     return f"Conteo total: {global_count}"
 
 
-# --- INTERFAZ ---
+# =============== interfaz ===============
 with gr.Blocks() as demo:
-    gr.Markdown("## 🧫 Contador de larvas – v5 (ajustado y sensible)")
+    gr.Markdown("## Contador de larvas – v6 (rangos amplios y alineado)")
 
     with gr.Row():
         with gr.Column(scale=1):
             inp = gr.Image(label="Subí la foto")
 
             thresh = gr.Slider(0, 300, 10, 1, label="Umbral (0=Otsu auto)")
-            min_area = gr.Slider(0, 300, 4, 1, label="Min área px²")
-            max_area_single = gr.Slider(0, 300, 38, 1, label="Máx área 1 larva px²")
+            min_area = gr.Slider(0, 300, 6, 1, label="Min área px²")
+            max_area_single = gr.Slider(0, 300, 40, 1, label="Máx área 1 larva px²")
 
             btn = gr.Button("Procesar")
             btn_reset = gr.Button("Reset contador")
@@ -181,9 +201,11 @@ with gr.Blocks() as demo:
             out_txt = gr.Textbox(label="Resultado individual")
             out_total = gr.Textbox(label="Resultado acumulado")
 
-    btn.click(process,
-              inputs=[inp, thresh, min_area, max_area_single],
-              outputs=[out_img, out_txt, out_total])
+    btn.click(
+        process,
+        inputs=[inp, thresh, min_area, max_area_single],
+        outputs=[out_img, out_txt, out_total]
+    )
     btn_reset.click(reset, [], [out_total])
 
 demo.launch(debug=True)