33

app.py

@@ -5,11 +5,9 @@ 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=["*"],
@@ -18,94 +16,107 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+def to_data_uri_rgb(img_rgb: np.ndarray) -> str:
+    # img_rgb: HxWx3 uint8
+    if img_rgb is None or img_rgb.size == 0:
+        return None
+    bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+    ok, buf = cv2.imencode(".png", bgr)
+    if not ok:
+        return None
+    import base64
+    b64 = base64.b64encode(buf.tobytes()).decode("ascii")
+    return f"data:image/png;base64,{b64}"
+
 def process_image_bytes(img_bytes: bytes):
-    # lê bytes em numpy + OpenCV
+    # 0) decodificar bytes
     nparr = np.frombuffer(img_bytes, np.uint8)
-    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    img = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)
+
+    if img is None:
+        raise ValueError("Não foi possível decodificar a imagem enviada.")
+
+    # 0.1) garantir BGR (remover alpha se existir)
+    if img.ndim == 2:
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    elif img.shape[2] == 4:
+        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+
+    # 1) equalização local leve para realçar contraste (CLAHE no L do LAB)
     lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
     l, a, b = cv2.split(lab)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-    l_clahe = clahe.apply(l)
-    lab_clahe = cv2.merge([l_clahe, a, b])
-    img = cv2.cvtColor(lab_clahe, cv2.COLOR_LAB2BGR)
-    
-    if img is None:
-        raise ValueError("Não foi possível decodificar a imagem.")
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    l = clahe.apply(l)
+    img = cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
 
-    # 1) Converter para HSV
+    # 2) HSV e máscara de fundo preto
     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)
+    # 3) 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)
+    # 4) maior componente (parafuso)
     contours, _ = cv2.findContours(mask_obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     if not contours:
-        return {"error": "Nenhum objeto detectado"}
+        return {
+            "percent": 0.0,
+            "total_pixels": 0,
+            "corrosion_pixels": 0,
+            "isolated_image": None,
+            "corrosion_image": None,
+            "warning": "Nenhum objeto detectado (fundo pode não ser preto)."
+        }
 
     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
+    # 5) isolar objeto
     isolated = cv2.bitwise_and(img, img, mask=mask_clean)
 
-    # 7) detectar corrosão BRANCA (S baixa, V alta)
+    # 6) detectar CORROSÃO BRANCA (S baixa e 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
+    # 7) 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
+    # 8) imagens para o front (RGB + data URI)
     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,
+        "isolated_image": to_data_uri_rgb(isolated_rgb),
+        "corrosion_image": to_data_uri_rgb(corrosion_vis),
     }
 
 @app.post("/analyze")
 async def analyze(file: UploadFile = File(...)):
-    content = await file.read()
     try:
+        content = await file.read()
         result = process_image_bytes(content)
+        return JSONResponse(result, status_code=200)
     except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    return JSONResponse(result)
+        # erro esperado do usuário/entrada -> 400 com JSON
+        return JSONResponse({"error": str(e)}, status_code=400)
+    except Exception as e:
+        # qualquer outra falha -> ainda responder JSON, não HTML
+        return JSONResponse({"error": f"Falha interna: {type(e).__name__}: {str(e)}"}, status_code=500)
 
 @app.get("/")
 def read_root():
-    return {"status": "ok"}
+    return {"status": "ok"}