GTeste

app.py

@@ -109,7 +109,6 @@
 # def read_root():
 #     return {"status": "ok"}
 
-
 # app.py
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
@@ -120,17 +119,20 @@ import base64
 import traceback
 from typing import Dict, List
 
-app = FastAPI(title="Detector de Corrosão Branca")
+app = FastAPI(title="Detector de Corrosão Branca — multi-objetos (notebook-based)")
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # restrinja em produção
+    allow_origins=["*"],   # restrinja em produção
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# ----------------- utils -----------------
 def to_data_uri_rgb(img_rgb: np.ndarray) -> str | None:
+    if img_rgb is None:
+        return None
     bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
     ok, buf = cv2.imencode(".png", bgr)
     if not ok:
@@ -138,122 +140,185 @@ def to_data_uri_rgb(img_rgb: np.ndarray) -> str | None:
     b64 = base64.b64encode(buf.tobytes()).decode("ascii")
     return f"data:image/png;base64,{b64}"
 
-def process_one_object(img_bgr: np.ndarray, obj_mask: np.ndarray) -> Dict:
-    isolated = cv2.bitwise_and(img_bgr, img_bgr, mask=obj_mask)
-    hsv = cv2.cvtColor(isolated, cv2.COLOR_BGR2HSV)
-
-    # "branco" (S baixo, V alto) — ajuste se necessário
+def feather_mask(mask_u8: np.ndarray, feather_px: float) -> np.ndarray:
+    """Retorna máscara float32 [0..1] com feather (Gaussiano) opcional."""
+    if feather_px and feather_px > 0:
+        alpha = cv2.GaussianBlur(mask_u8, (0, 0), feather_px).astype(np.float32) / 255.0
+    else:
+        alpha = (mask_u8.astype(np.float32) / 255.0)
+    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."""
+    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)
     lower_white = np.array([0, 0, 180], dtype=np.uint8)
     upper_white = np.array([180, 60, 255], dtype=np.uint8)
-    mask_white = cv2.inRange(hsv, lower_white, upper_white)
-    mask_white = cv2.bitwise_and(mask_white, mask_white, mask=obj_mask)
-
-    total_pixels = int(np.count_nonzero(obj_mask))
-    corrosion_pixels = int(np.count_nonzero(mask_white))
-    percent = (corrosion_pixels / max(1, total_pixels)) * 100.0
-
-    iso_rgb = cv2.cvtColor(isolated, cv2.COLOR_BGR2RGB)
-    corro_vis = cv2.bitwise_and(iso_rgb, iso_rgb, mask=mask_white)
-
-    return {
-        "total_pixels": total_pixels,
-        "corrosion_pixels": corrosion_pixels,
-        "percent": round(percent, 4),
-        "isolated_image": to_data_uri_rgb(iso_rgb),
-        "corrosion_image": to_data_uri_rgb(corro_vis),
-    }
-
-def process_image_bytes_multi(img_bytes: bytes, min_area: int = 1500, sort: str = "x") -> Dict:
+    m = cv2.inRange(hsv, lower_white, upper_white)
+    return cv2.bitwise_and(m, m, mask=obj_mask)
+
+# ----------------- core -----------------
+def process_image_bytes_multi(
+    img_bytes: bytes,
+    margem: int = 5,
+    min_area_rel: float = 1/30000,
+    kernel_sz: int = 3,
+    dilatacao_px: float = 0.5,
+    feather_px: float = 1.0,
+    sort: str = "x",
+) -> Dict:
+    # decodifica
     nparr = np.frombuffer(img_bytes, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
     if img is None:
         raise ValueError("Não foi possível decodificar a imagem.")
-
-    # CLAHE no canal L (corrigido para cv2)
-    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    l2 = clahe.apply(l)
-    lab2 = cv2.merge([l2, a, b])
-    img = cv2.cvtColor(lab2, cv2.COLOR_LAB2BGR)
-
-    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
-    lower_bg = np.array([0, 0, 0], dtype=np.uint8)
-    upper_bg = np.array([180, 255, 50], dtype=np.uint8)
-    mask_bg = cv2.inRange(hsv, lower_bg, upper_bg)
-    mask_obj = cv2.bitwise_not(mask_bg)
-
-    kernel = np.ones((5, 5), np.uint8)
-    mask_obj = cv2.morphologyEx(mask_obj, cv2.MORPH_OPEN, kernel)
-    mask_obj = cv2.morphologyEx(mask_obj, cv2.MORPH_CLOSE, kernel)
-
-    contours, _ = cv2.findContours(mask_obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return {"error": "Nenhum objeto detectado", "items": [], "total_objects": 0}
-
-    # filtra objetos pequenos
+    H, W = img.shape[:2]
+
+    # --- pré-processamento conforme 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))
+    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))
+        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 = []
-    for c in contours:
+    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": "Somente ruído abaixo do min_area", "items": [], "total_objects": 0}
+        return {"error": "Nenhum objeto detectado acima do limiar", "items": [], "total_objects": 0}
 
-    cand.sort(key=(lambda d: d["area"]), reverse=(sort == "area"))
-    if sort == "x":
-        cand.sort(key=lambda d: d["bbox"][0])
+    # ordenação
+    if sort == "area":
+        cand.sort(key=lambda d: d["area"], reverse=True)
+    else:
+        cand.sort(key=lambda d: d["bbox"][0])  # por X
 
-    # overview com caixas verdes
+    # overview com retângulos verdes
     overview = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
+
     items: List[Dict] = []
-    tot_pix = 0
-    tot_cor = 0
+    total_pix = 0
+    total_cor = 0
 
-    h, w = mask_obj.shape[:2]
-    for i, c in enumerate(cand, 1):
-        obj_mask = np.zeros((h, w), dtype=np.uint8)
-        cv2.drawContours(obj_mask, [c["contour"]], -1, 255, cv2.FILLED)
+    for idx, c in enumerate(cand, 1):
+        x, y, w, h = c["bbox"]
 
-        r = process_one_object(img, obj_mask)
-        tot_pix += r["total_pixels"]
-        tot_cor += r["corrosion_pixels"]
+        # ROI com margem, clamped
+        x0 = max(x - margem, 0)
+        y0 = max(y - margem, 0)
+        x1 = min(x + w + margem, W)
+        y1 = min(y + h + margem, H)
 
-        x, y, ww, hh = c["bbox"]
-        cv2.rectangle(overview, (x, y), (x + ww, y + hh), (0, 255, 0), 2)
-        cv2.putText(overview, f"#{i} {r['percent']:.1f}%",
-                    (x, max(0, y - 6)), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
-                    (255, 50, 50), 2, cv2.LINE_AA)
+        roi_bgr = img[y0:y1, x0:x1].copy()
+
+        # máscara do contorno deslocado para ROI
+        mask_roi = np.zeros((y1 - y0, x1 - x0), dtype=np.uint8)
+        c_shift = c["contour"] - [x0, y0]
+        cv2.drawContours(mask_roi, [c_shift], -1, 255, thickness=-1)
+
+        # feather -> alpha 0..1
+        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
+        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)
+
+        total_pixels = int(np.count_nonzero(obj_mask_full))
+        corrosion_pixels = int(np.count_nonzero(mask_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
+        for ch in range(3):
+            corro_vis_rgb[..., ch] = cv2.bitwise_and(corro_vis_rgb[..., ch], mask_white_roi)
 
         items.append({
-            "id": i,
-            "bbox": {"x": x, "y": y, "w": ww, "h": hh},
+            "id": idx,
+            "bbox": {"x": int(x), "y": int(y), "w": int(w), "h": int(h)},
             "area_pixels": int(c["area"]),
-            **r,
+            "total_pixels": total_pixels,
+            "corrosion_pixels": corrosion_pixels,
+            "percent": round(percent, 4),
+            "isolated_image": to_data_uri_rgb(iso_rgb),
+            "corrosion_image": to_data_uri_rgb(corro_vis_rgb),
         })
 
-    overall = (tot_cor / max(1, tot_pix)) * 100.0
+        # desenha bbox + label 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)
+
+    overall = (total_cor / max(1, total_pix)) * 100.0
 
     return {
         "total_objects": len(items),
         "items": items,
-        "total_pixels": int(tot_pix),
-        "total_corrosion_pixels": int(tot_cor),
+        "total_pixels": int(total_pix),
+        "total_corrosion_pixels": int(total_cor),
         "overall_percent": round(overall, 4),
         "overview_image": to_data_uri_rgb(overview),
     }
 
+# ----------------- API -----------------
 @app.post("/analyze")
 async def analyze(
     file: UploadFile = File(...),
-    min_area: int = Query(1500, ge=1),
+    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'"),
     sort: str = Query("x", pattern="^(x|area)$"),
 ):
     try:
         content = await file.read()
-        result = process_image_bytes_multi(content, min_area=min_area, sort=sort)
+        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,
+        )
         return JSONResponse(result)
     except HTTPException:
         raise
@@ -264,3 +329,4 @@ async def analyze(
 @app.get("/")
 def read_root():
     return {"status": "ok"}
+