Update app.py

app.py

@@ -1,15 +1,120 @@
+# # app.py
+# from fastapi import FastAPI, File, UploadFile, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.responses import JSONResponse
+# import numpy as np
+# import cv2
+# import base64
+# import io
+
+# app = FastAPI(title="Detector de Corrosão Branca")
+
+# # PARA PROTOTIPO: permitir todas origens. Em produção restrinja ao domínio do frontend.
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# def process_image_bytes(img_bytes: bytes):
+#     # lê bytes em numpy + OpenCV
+#     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.")
+
+#     # 1) Converter para HSV
+#     hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+
+#     # 2) máscara do fundo preto (V baixo)
+#     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)
+
+#     # 3) objeto = invertendo máscara do fundo
+#     mask_obj = cv2.bitwise_not(mask_bg)
+
+#     # 4) limpar máscara (morfologia)
+#     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)
+
+#     # 5) maior contorno (supõe um parafuso)
+#     contours, _ = cv2.findContours(mask_obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#     if not contours:
+#         return {"error": "Nenhum objeto detectado"}
+
+#     largest = max(contours, key=cv2.contourArea)
+#     mask_clean = np.zeros_like(mask_obj)
+#     cv2.drawContours(mask_clean, [largest], -1, 255, cv2.FILLED)
+
+#     # 6) isolar objeto
+#     isolated = cv2.bitwise_and(img, img, mask=mask_clean)
+
+#     # 7) detectar corrosão BRANCA (S baixa, V alta)
+#     hsv_iso = cv2.cvtColor(isolated, 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_iso, lower_white, upper_white)
+#     mask_white = cv2.bitwise_and(mask_white, mask_white, mask=mask_clean)
+
+#     # 8) métricas
+#     total_pixels = int(np.count_nonzero(mask_clean))
+#     corrosion_pixels = int(np.count_nonzero(mask_white))
+#     percent = (corrosion_pixels / max(1, total_pixels)) * 100.0
+
+#     # 9) preparar imagens para frontend (PNG base64)
+#     # isolado em RGB para visualização
+#     isolated_rgb = cv2.cvtColor(isolated, cv2.COLOR_BGR2RGB)
+#     corrosion_vis = cv2.bitwise_and(isolated_rgb, isolated_rgb, mask=mask_white)
+
+#     def to_data_uri(img_arr):
+#         # img_arr: RGB uint8
+#         bgr = cv2.cvtColor(img_arr, cv2.COLOR_RGB2BGR)
+#         ok, buf = cv2.imencode(".png", bgr)
+#         if not ok:
+#             return None
+#         b64 = base64.b64encode(buf.tobytes()).decode("ascii")
+#         return f"data:image/png;base64,{b64}"
+
+#     isolated_b64 = to_data_uri(isolated_rgb)
+#     corrosion_b64 = to_data_uri(corrosion_vis)
+
+#     return {
+#         "percent": round(percent, 4),
+#         "total_pixels": total_pixels,
+#         "corrosion_pixels": corrosion_pixels,
+#         "isolated_image": isolated_b64,
+#         "corrosion_image": corrosion_b64,
+#     }
+
+# @app.post("/analyze")
+# async def analyze(file: UploadFile = File(...)):
+#     content = await file.read()
+#     try:
+#         result = process_image_bytes(content)
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     return JSONResponse(result)
+
+# @app.get("/")
+# def read_root():
+#     return {"status": "ok"}
+
 # app.py
-from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi import FastAPI, File, UploadFile, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 import numpy as np
 import cv2
 import base64
-import io
+from typing import List, Dict
 
-app = FastAPI(title="Detector de Corrosão Branca")
+app = FastAPI(title="Detector de Corrosão Branca (multi-objetos)")
 
-# PARA PROTOTIPO: permitir todas origens. Em produção restrinja ao domínio do frontend.
+# CORS (ajuste allow_origins em produção)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -18,83 +123,153 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-def process_image_bytes(img_bytes: bytes):
-    # lê bytes em numpy + OpenCV
+def to_data_uri_from_rgb(img_rgb: np.ndarray) -> str | None:
+    """Recebe imagem RGB uint8 e retorna data URI PNG."""
+    if img_rgb is None:
+        return None
+    bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+    ok, buf = cv2.imencode(".png", bgr)
+    if not ok:
+        return 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:
+    """
+    Calcula métricas e imagens para um único objeto (parafuso).
+    - img_bgr: imagem original BGR
+    - obj_mask: máscara binária 0/255 do objeto (mesmo tamanho da imagem)
+    """
+    # isolar objeto em BGR e converter para RGB p/ visualização
+    isolated = cv2.bitwise_and(img_bgr, img_bgr, mask=obj_mask)
+    isolated_rgb = cv2.cvtColor(isolated, cv2.COLOR_BGR2RGB)
+
+    # corrosão branca: S baixo, V alto (em HSV)
+    hsv_iso = cv2.cvtColor(isolated, 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_iso, 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
+
+    # visual da corrosão em cima do isolado
+    corrosion_vis = cv2.bitwise_and(isolated_rgb, isolated_rgb, mask=mask_white)
+
+    return {
+        "total_pixels": total_pixels,
+        "corrosion_pixels": corrosion_pixels,
+        "percent": round(percent, 4),
+        "isolated_image": to_data_uri_from_rgb(isolated_rgb),
+        "corrosion_image": to_data_uri_from_rgb(corrosion_vis),
+    }
+
+def process_image_bytes_multi(img_bytes: bytes, min_area: int, max_items: int, sort: str):
+    # 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.")
 
-    # 1) Converter para HSV
-    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    h, w = img.shape[:2]
 
-    # 2) máscara do fundo preto (V baixo)
+    # HSV + fundo preto
+    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)
-
-    # 3) objeto = invertendo máscara do fundo
     mask_obj = cv2.bitwise_not(mask_bg)
 
-    # 4) limpar máscara (morfologia)
+    # limpeza morfológica
     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)
 
-    # 5) maior contorno (supõe um parafuso)
+    # contornos externos
     contours, _ = cv2.findContours(mask_obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     if not contours:
-        return {"error": "Nenhum objeto detectado"}
+        return {"error": "Nenhum objeto detectado", "items": []}
 
-    largest = max(contours, key=cv2.contourArea)
-    mask_clean = np.zeros_like(mask_obj)
-    cv2.drawContours(mask_clean, [largest], -1, 255, cv2.FILLED)
+    # filtra por área
+    candidates = []
+    for c in contours:
+        area = cv2.contourArea(c)
+        if area >= max(1, min_area):
+            x, y, ww, hh = cv2.boundingRect(c)
+            candidates.append({"contour": c, "area": area, "bbox": (x, y, ww, hh)})
 
-    # 6) isolar objeto
-    isolated = cv2.bitwise_and(img, img, mask=mask_clean)
+    if not candidates:
+        return {"error": "Somente ruído encontrado abaixo do min_area", "items": []}
 
-    # 7) detectar corrosão BRANCA (S baixa, V alta)
-    hsv_iso = cv2.cvtColor(isolated, 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_iso, lower_white, upper_white)
-    mask_white = cv2.bitwise_and(mask_white, mask_white, mask=mask_clean)
+    # ordenação
+    if sort == "area":
+        candidates.sort(key=lambda d: d["area"], reverse=True)
+    else:  # "x" (esquerda -> direita)
+        candidates.sort(key=lambda d: d["bbox"][0])
 
-    # 8) métricas
-    total_pixels = int(np.count_nonzero(mask_clean))
-    corrosion_pixels = int(np.count_nonzero(mask_white))
-    percent = (corrosion_pixels / max(1, total_pixels)) * 100.0
+    candidates = candidates[:max_items]
 
-    # 9) preparar imagens para frontend (PNG base64)
-    # isolado em RGB para visualização
-    isolated_rgb = cv2.cvtColor(isolated, cv2.COLOR_BGR2RGB)
-    corrosion_vis = cv2.bitwise_and(isolated_rgb, isolated_rgb, mask=mask_white)
+    # imagem de overview (RGB) p/ desenhar anotações
+    overview = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
+
+    items: List[Dict] = []
+    total_pixels_sum = 0
+    corrosion_pixels_sum = 0
+
+    for idx, obj in enumerate(candidates, 1):
+        c = obj["contour"]
+        x, y, ww, hh = obj["bbox"]
+
+        # máscara do objeto atual
+        obj_mask = np.zeros((h, w), dtype=np.uint8)
+        cv2.drawContours(obj_mask, [c], -1, 255, cv2.FILLED)
+
+        # métricas e imagens do objeto
+        r = process_one_object(img, obj_mask)
 
-    def to_data_uri(img_arr):
-        # img_arr: RGB uint8
-        bgr = cv2.cvtColor(img_arr, cv2.COLOR_RGB2BGR)
-        ok, buf = cv2.imencode(".png", bgr)
-        if not ok:
-            return None
-        b64 = base64.b64encode(buf.tobytes()).decode("ascii")
-        return f"data:image/png;base64,{b64}"
+        # acumula totais
+        total_pixels_sum += r["total_pixels"]
+        corrosion_pixels_sum += r["corrosion_pixels"]
 
-    isolated_b64 = to_data_uri(isolated_rgb)
-    corrosion_b64 = to_data_uri(corrosion_vis)
+        # desenha no overview
+        cv2.rectangle(overview, (x, y), (x + ww, y + hh), (0, 255, 0), 2)
+        label = f"#{idx} {r['percent']:.2f}%"
+        cv2.putText(overview, label, (x, max(0, y - 6)),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 50, 50), 2, cv2.LINE_AA)
+
+        items.append({
+            "id": idx,
+            "bbox": {"x": x, "y": y, "w": ww, "h": hh},
+            "area_pixels": int(obj["area"]),
+            **r,  # total_pixels, corrosion_pixels, percent, images...
+        })
+
+    overall_percent = (corrosion_pixels_sum / max(1, total_pixels_sum)) * 100.0
+
+    # adiciona overview
+    overview_data_uri = to_data_uri_from_rgb(overview)
 
     return {
-        "percent": round(percent, 4),
-        "total_pixels": total_pixels,
-        "corrosion_pixels": corrosion_pixels,
-        "isolated_image": isolated_b64,
-        "corrosion_image": corrosion_b64,
+        "total_objects": len(items),
+        "items": items,
+        "total_pixels": int(total_pixels_sum),
+        "total_corrosion_pixels": int(corrosion_pixels_sum),
+        "overall_percent": round(overall_percent, 4),
+        "overview_image": overview_data_uri,
     }
 
 @app.post("/analyze")
-async def analyze(file: UploadFile = File(...)):
+async def analyze(
+    file: UploadFile = File(...),
+    min_area: int = Query(1500, ge=1, description="Área mínima do objeto (px)"),
+    max_items: int = Query(20, ge=1, le=200, description="Limite de objetos"),
+    sort: str = Query("x", pattern="^(x|area)$", description="Ordenação: x|area"),
+):
     content = await file.read()
     try:
-        result = process_image_bytes(content)
+        result = process_image_bytes_multi(content, min_area=min_area, max_items=max_items, sort=sort)
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
     return JSONResponse(result)
@@ -102,3 +277,4 @@ async def analyze(file: UploadFile = File(...)):
 @app.get("/")
 def read_root():
     return {"status": "ok"}
+