GTeste

app.py

@@ -1,110 +1,266 @@
+# # 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)
+#     lab = cv.cvtColor(img, cv.COLOR_BGR2LAB)
+#     l, a, b = cv.split(lab)
+#     clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+#     l_clahe = clahe.apply(l)
+#     lab_clahe = cv.merge([l_clahe, a, b])
+#     img = cv.cvtColor(lab_clahe, cv.COLOR_LAB2BGR)
+#     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
+import traceback
+from typing import Dict, List
 
 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_origins=["*"],  # restrinja em produção
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-def process_image_bytes(img_bytes: bytes):
-    # lê bytes em numpy + OpenCV
+def to_data_uri_rgb(img_rgb: np.ndarray) -> str | 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:
+    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
+    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:
     nparr = np.frombuffer(img_bytes, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-    lab = cv.cvtColor(img, cv.COLOR_BGR2LAB)
-    l, a, b = cv.split(lab)
-    clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    l_clahe = clahe.apply(l)
-    lab_clahe = cv.merge([l_clahe, a, b])
-    img = cv.cvtColor(lab_clahe, cv.COLOR_LAB2BGR)
     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)
+    # 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)
 
-    # 2) máscara do fundo preto (V baixo)
+    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)
     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"}
+        return {"error": "Nenhum objeto detectado", "items": [], "total_objects": 0}
 
-    largest = max(contours, key=cv2.contourArea)
-    mask_clean = np.zeros_like(mask_obj)
-    cv2.drawContours(mask_clean, [largest], -1, 255, cv2.FILLED)
+    # filtra objetos pequenos
+    cand = []
+    for c in contours:
+        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)})
 
-    # 6) isolar objeto
-    isolated = cv2.bitwise_and(img, img, mask=mask_clean)
+    if not cand:
+        return {"error": "Somente ruído abaixo do min_area", "items": [], "total_objects": 0}
 
-    # 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)
+    cand.sort(key=(lambda d: d["area"]), reverse=(sort == "area"))
+    if sort == "x":
+        cand.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
+    # overview com caixas verdes
+    overview = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
+    items: List[Dict] = []
+    tot_pix = 0
+    tot_cor = 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)
+    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)
 
-    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}"
+        r = process_one_object(img, obj_mask)
+        tot_pix += r["total_pixels"]
+        tot_cor += r["corrosion_pixels"]
 
-    isolated_b64 = to_data_uri(isolated_rgb)
-    corrosion_b64 = to_data_uri(corrosion_vis)
+        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)
+
+        items.append({
+            "id": i,
+            "bbox": {"x": x, "y": y, "w": ww, "h": hh},
+            "area_pixels": int(c["area"]),
+            **r,
+        })
+
+    overall = (tot_cor / max(1, tot_pix)) * 100.0
 
     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(tot_pix),
+        "total_corrosion_pixels": int(tot_cor),
+        "overall_percent": round(overall, 4),
+        "overview_image": to_data_uri_rgb(overview),
     }
 
 @app.post("/analyze")
-async def analyze(file: UploadFile = File(...)):
-    content = await file.read()
+async def analyze(
+    file: UploadFile = File(...),
+    min_area: int = Query(1500, ge=1),
+    sort: str = Query("x", pattern="^(x|area)$"),
+):
     try:
-        result = process_image_bytes(content)
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    return JSONResponse(result)
+        content = await file.read()
+        result = process_image_bytes_multi(content, min_area=min_area, sort=sort)
+        return JSONResponse(result)
+    except HTTPException:
+        raise
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=400, detail=f"processing_error: {e}")
 
 @app.get("/")
 def read_root():
-    return {"status": "ok"}
+    return {"status": "ok"}