Testeg1

app.py

@@ -108,8 +108,6 @@
 # @app.get("/")
 # def read_root():
 #     return {"status": "ok"}
-
-# app.py
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -119,17 +117,18 @@ import base64
 import traceback
 from typing import Dict, List
 
-app = FastAPI(title="Detector de Corrosão Branca — multi-objetos (notebook-based)")
+app = FastAPI(title="Detector de Corrosão Branca — multi-objetos")
 
+# Em produção, restrinja allow_origins ao seu domínio
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],   # restrinja em produção
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# ----------------- utils -----------------
+# ----------------- utilidades -----------------
 def to_data_uri_rgb(img_rgb: np.ndarray) -> str | None:
     if img_rgb is None:
         return None
@@ -141,7 +140,7 @@ def to_data_uri_rgb(img_rgb: np.ndarray) -> str | None:
     return f"data:image/png;base64,{b64}"
 
 def feather_mask(mask_u8: np.ndarray, feather_px: float) -> np.ndarray:
-    """Retorna máscara float32 [0..1] com feather (Gaussiano) opcional."""
+    """Mask float [0..1] com feather opcional."""
     if feather_px and feather_px > 0:
         alpha = cv2.GaussianBlur(mask_u8, (0, 0), feather_px).astype(np.float32) / 255.0
     else:
@@ -149,27 +148,33 @@ def feather_mask(mask_u8: np.ndarray, feather_px: float) -> np.ndarray:
     return np.clip(alpha, 0.0, 1.0)
 
 def compose_on_black(bgr: np.ndarray, alpha01: np.ndarray) -> np.ndarray:
-    """Aplica alpha (H×W float [0..1]) sobre imagem BGR e retorna RGB uint8 com fundo preto."""
+    """Aplica alpha na ROI BGR e retorna RGB uint8 em fundo preto."""
     comp = (bgr.astype(np.float32) * alpha01[..., None]).astype(np.uint8)
     return cv2.cvtColor(comp, cv2.COLOR_BGR2RGB)
 
-def corrosion_mask_from_isolated(bgr: np.ndarray, obj_mask: np.ndarray) -> np.ndarray:
-    """Detecta 'corrosão branca' (S baixo, V alto) dentro da máscara do objeto."""
-    hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)
+def corrosion_mask_from_obj(bgr_full: np.ndarray, obj_mask_full: np.ndarray) -> np.ndarray:
+    """'Corrosão branca' = S baixo, V alto dentro do objeto."""
+    hsv = cv2.cvtColor(bgr_full, cv2.COLOR_BGR2HSV)
     lower_white = np.array([0, 0, 180], dtype=np.uint8)
     upper_white = np.array([180, 60, 255], dtype=np.uint8)
     m = cv2.inRange(hsv, lower_white, upper_white)
-    return cv2.bitwise_and(m, m, mask=obj_mask)
+    return cv2.bitwise_and(m, m, mask=obj_mask_full)
 
 # ----------------- core -----------------
 def process_image_bytes_multi(
     img_bytes: bytes,
-    margem: int = 5,
-    min_area_rel: float = 1/30000,
+    margem: int = 6,
+    min_area_rel: float = 1/20000,
+    max_area_rel: float = 0.25,
     kernel_sz: int = 3,
-    dilatacao_px: float = 0.5,
+    dilatacao_px: float = 1.0,
     feather_px: float = 1.0,
     sort: str = "x",
+    ar_min: float = 0.6,
+    ar_max: float = 1.6,
+    exclude_border: int = 8,
+    min_solidity: float = 0.75,
+    min_circ: float = 0.35,
 ) -> Dict:
     # decodifica
     nparr = np.frombuffer(img_bytes, np.uint8)
@@ -177,60 +182,106 @@ def process_image_bytes_multi(
     if img is None:
         raise ValueError("Não foi possível decodificar a imagem.")
     H, W = img.shape[:2]
+    img_area = H * W
 
-    # --- pré-processamento conforme notebook ---
+    # --- segmentação estilo notebook ---
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     gray = cv2.GaussianBlur(gray, (5, 5), 0)
 
-    # Otsu (inv) + Adaptativa (inv) -> OR
     _, thr_otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
     thr_adap = cv2.adaptiveThreshold(
         gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 51, 2
     )
     thr = cv2.bitwise_or(thr_otsu, thr_adap)
 
-    # morfologia (fechamento)
-    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (max(1, kernel_sz)|1, max(1, kernel_sz)|1))
+    ksz = max(1, kernel_sz) | 1
+    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ksz, ksz))
     thr = cv2.morphologyEx(thr, cv2.MORPH_CLOSE, k, iterations=1)
 
-    # dilatação extra (se solicitado)
     if dilatacao_px and dilatacao_px > 0:
-        ksz = int(2 * dilatacao_px + 1)
-        ksz = max(1, ksz) | 1  # ímpar
-        k_dil = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ksz, ksz))
+        dsz = int(2 * dilatacao_px + 1)
+        dsz = max(1, dsz) | 1
+        k_dil = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (dsz, dsz))
         thr = cv2.dilate(thr, k_dil, iterations=1)
 
-    # contornos externos
     cnts, _ = cv2.findContours(thr, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
-    min_area = max(200, int((H * W) * min_area_rel))
-    cand = []
+    # --- filtros geométricos ---
+    min_area = max(200, int(img_area * min_area_rel))
+    max_area = int(img_area * max_area_rel)
+
+    filters_stats = {
+        "total_cnts": len(cnts),
+        "too_small": 0,
+        "too_big": 0,
+        "aspect_ratio": 0,
+        "border_touch": 0,
+        "low_solidity": 0,
+        "low_circularity": 0,
+    }
+
+    candidates = []
     for c in cnts:
         area = cv2.contourArea(c)
-        if area >= min_area:
-            x, y, w, h = cv2.boundingRect(c)
-            cand.append({"contour": c, "area": area, "bbox": (x, y, w, h)})
-
-    if not cand:
-        return {"error": "Nenhum objeto detectado acima do limiar", "items": [], "total_objects": 0}
+        if area < min_area:
+            filters_stats["too_small"] += 1
+            continue
+        if area > max_area:
+            filters_stats["too_big"] += 1
+            continue
+
+        x, y, w, h = cv2.boundingRect(c)
+
+        if exclude_border > 0 and (
+            x <= exclude_border or y <= exclude_border or
+            x + w >= W - exclude_border or y + h >= H - exclude_border
+        ):
+            filters_stats["border_touch"] += 1
+            continue
+
+        ar = (w / h) if h > 0 else 0
+        if ar < ar_min or ar > ar_max:
+            filters_stats["aspect_ratio"] += 1
+            continue
+
+        hull = cv2.convexHull(c)
+        hull_area = cv2.contourArea(hull) or 1.0
+        solidity = area / hull_area
+        if solidity < min_solidity:
+            filters_stats["low_solidity"] += 1
+            continue
+
+        perim = cv2.arcLength(c, True) or 1.0
+        circularity = (4.0 * np.pi * area) / (perim * perim)
+        if circularity < min_circ:
+            filters_stats["low_circularity"] += 1
+            continue
+
+        candidates.append({"contour": c, "area": area, "bbox": (x, y, w, h)})
+
+    if not candidates:
+        return {
+            "error": "Nenhum objeto após filtros",
+            "items": [],
+            "total_objects": 0,
+            "filters_stats": filters_stats,
+        }
 
-    # ordenação
     if sort == "area":
-        cand.sort(key=lambda d: d["area"], reverse=True)
+        candidates.sort(key=lambda d: d["area"], reverse=True)
     else:
-        cand.sort(key=lambda d: d["bbox"][0])  # por X
+        candidates.sort(key=lambda d: d["bbox"][0])  # por X (esq→dir)
 
-    # overview com retângulos verdes
+    # --- overview + métricas ---
     overview = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
-
     items: List[Dict] = []
     total_pix = 0
     total_cor = 0
 
-    for idx, c in enumerate(cand, 1):
+    for idx, c in enumerate(candidates, 1):
         x, y, w, h = c["bbox"]
 
-        # ROI com margem, clamped
+        # ROI com margem (clamped)
         x0 = max(x - margem, 0)
         y0 = max(y - margem, 0)
         x1 = min(x + w + margem, W)
@@ -243,32 +294,27 @@ def process_image_bytes_multi(
         c_shift = c["contour"] - [x0, y0]
         cv2.drawContours(mask_roi, [c_shift], -1, 255, thickness=-1)
 
-        # feather -> alpha 0..1
+        # feather + composição isolada
         alpha01 = feather_mask(mask_roi, feather_px)
-
-        # composição no fundo preto (isolado)
         iso_rgb = compose_on_black(roi_bgr, alpha01)
 
-        # para métricas de corrosão, crie máscara do objeto no espaço original
+        # métricas de corrosão no espaço original
         obj_mask_full = np.zeros((H, W), dtype=np.uint8)
         cv2.drawContours(obj_mask_full, [c["contour"]], -1, 255, thickness=-1)
 
-        # métricas de corrosão (no original, limitado à máscara do objeto)
-        mask_white_full = corrosion_mask_from_isolated(img, obj_mask_full)
-
+        white_full = corrosion_mask_from_obj(img, obj_mask_full)
         total_pixels = int(np.count_nonzero(obj_mask_full))
-        corrosion_pixels = int(np.count_nonzero(mask_white_full))
+        corrosion_pixels = int(np.count_nonzero(white_full))
         percent = (corrosion_pixels / max(1, total_pixels)) * 100.0
 
         total_pix += total_pixels
         total_cor += corrosion_pixels
 
-        # visual da corrosão limitado à ROI (em cima do isolado)
-        mask_white_roi = mask_white_full[y0:y1, x0:x1]
-        corro_vis_rgb = (iso_rgb.copy()).astype(np.uint8)
-        # aplica como máscara no RGB já composto
+        # visual de corrosão na ROI
+        white_roi = white_full[y0:y1, x0:x1]
+        corro_vis_rgb = iso_rgb.copy()
         for ch in range(3):
-            corro_vis_rgb[..., ch] = cv2.bitwise_and(corro_vis_rgb[..., ch], mask_white_roi)
+            corro_vis_rgb[..., ch] = cv2.bitwise_and(corro_vis_rgb[..., ch], white_roi)
 
         items.append({
             "id": idx,
@@ -281,10 +327,11 @@ def process_image_bytes_multi(
             "corrosion_image": to_data_uri_rgb(corro_vis_rgb),
         })
 
-        # desenha bbox + label na overview
+        # desenha bbox + rótulo na overview
         cv2.rectangle(overview, (x, y), (x + w, y + h), (0, 255, 0), 2)
-        cv2.putText(overview, f"#{idx} {percent:.1f}%", (x, max(0, y - 6)),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 50, 50), 2, cv2.LINE_AA)
+        cv2.putText(overview, f"#{idx} {percent:.1f}%",
+                    (x, max(0, y - 6)), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
+                    (255, 50, 50), 2, cv2.LINE_AA)
 
     overall = (total_cor / max(1, total_pix)) * 100.0
 
@@ -295,29 +342,32 @@ def process_image_bytes_multi(
         "total_corrosion_pixels": int(total_cor),
         "overall_percent": round(overall, 4),
         "overview_image": to_data_uri_rgb(overview),
+        "filters_stats": filters_stats,
     }
 
 # ----------------- API -----------------
 @app.post("/analyze")
 async def analyze(
     file: UploadFile = File(...),
-    margem: int = Query(5, ge=0, description="pixels extras no recorte"),
-    min_area_rel: float = Query(1/30000, gt=0, description="fração da área total para filtrar ruído"),
-    kernel_sz: int = Query(3, ge=1, description="kernel morfológico (ímpar)"),
-    dilatacao_px: float = Query(0.5, ge=0, description="força da dilatação adicional"),
-    feather_px: float = Query(1.0, ge=0, description="raio do desfoque para tirar a 'áurea'"),
+    margem: int = Query(6, ge=0),
+    min_area_rel: float = Query(1/20000, gt=0),
+    max_area_rel: float = Query(0.25, gt=0, le=1.0),
+    kernel_sz: int = Query(3, ge=1),
+    dilatacao_px: float = Query(1.0, ge=0),
+    feather_px: float = Query(1.0, ge=0),
     sort: str = Query("x", pattern="^(x|area)$"),
+    ar_min: float = Query(0.6, gt=0),
+    ar_max: float = Query(1.6, gt=0),
+    exclude_border: int = Query(8, ge=0),
+    min_solidity: float = Query(0.75, ge=0, le=1.0),
+    min_circ: float = Query(0.35, ge=0, le=1.0),
 ):
     try:
         content = await file.read()
         result = process_image_bytes_multi(
-            content,
-            margem=margem,
-            min_area_rel=min_area_rel,
-            kernel_sz=kernel_sz,
-            dilatacao_px=dilatacao_px,
-            feather_px=feather_px,
-            sort=sort,
+            content, margem, min_area_rel, max_area_rel, kernel_sz,
+            dilatacao_px, feather_px, sort, ar_min, ar_max,
+            exclude_border, min_solidity, min_circ
         )
         return JSONResponse(result)
     except HTTPException:
@@ -330,3 +380,4 @@ async def analyze(
 def read_root():
     return {"status": "ok"}
 
+