Bove Teste

app.py

@@ -1,120 +1,15 @@
-# # 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, Query
+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
-from typing import List, Dict
+import io
 
-app = FastAPI(title="Detector de Corrosão Branca (multi-objetos)")
+app = FastAPI(title="Detector de Corrosão Branca")
 
-# CORS (ajuste allow_origins em produção)
+# PARA PROTOTIPO: permitir todas origens. Em produção restrinja ao domínio do frontend.
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -123,153 +18,90 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-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
+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.")
 
-    h, w = img.shape[:2]
-
-    # HSV + fundo preto
+    # 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)
 
-    # limpeza morfológica
+    # 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)
 
-    # contornos externos
+    # 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", "items": []}
-
-    # 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)})
-
-    if not candidates:
-        return {"error": "Somente ruído encontrado abaixo do min_area", "items": []}
-
-    # 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])
-
-    candidates = candidates[:max_items]
-
-    # 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
+        return {"error": "Nenhum objeto detectado"}
 
-    for idx, obj in enumerate(candidates, 1):
-        c = obj["contour"]
-        x, y, ww, hh = obj["bbox"]
+    largest = max(contours, key=cv2.contourArea)
+    mask_clean = np.zeros_like(mask_obj)
+    cv2.drawContours(mask_clean, [largest], -1, 255, cv2.FILLED)
 
-        # máscara do objeto atual
-        obj_mask = np.zeros((h, w), dtype=np.uint8)
-        cv2.drawContours(obj_mask, [c], -1, 255, cv2.FILLED)
+    # 6) isolar objeto
+    isolated = cv2.bitwise_and(img, img, mask=mask_clean)
 
-        # métricas e imagens do objeto
-        r = process_one_object(img, obj_mask)
-
-        # acumula totais
-        total_pixels_sum += r["total_pixels"]
-        corrosion_pixels_sum += r["corrosion_pixels"]
+    # 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)
 
-        # 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)
+    # 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
 
-        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...
-        })
+    # 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)
 
-    overall_percent = (corrosion_pixels_sum / max(1, total_pixels_sum)) * 100.0
+    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}"
 
-    # adiciona overview
-    overview_data_uri = to_data_uri_from_rgb(overview)
+    isolated_b64 = to_data_uri(isolated_rgb)
+    corrosion_b64 = to_data_uri(corrosion_vis)
 
     return {
-        "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,
+        "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(...),
-    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"),
-):
+async def analyze(file: UploadFile = File(...)):
     content = await file.read()
     try:
-        result = process_image_bytes_multi(content, min_area=min_area, max_items=max_items, sort=sort)
+        result = process_image_bytes(content)
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
     return JSONResponse(result)
@@ -278,3 +110,178 @@ async def analyze(
 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
+# import numpy as np
+# import cv2
+# import base64
+# from typing import List, Dict
+
+# app = FastAPI(title="Detector de Corrosão Branca (multi-objetos)")
+
+# # CORS (ajuste allow_origins em produção)
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# 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.")
+
+#     h, w = img.shape[:2]
+
+#     # 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)
+#     mask_obj = cv2.bitwise_not(mask_bg)
+
+#     # 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)
+
+#     # contornos externos
+#     contours, _ = cv2.findContours(mask_obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#     if not contours:
+#         return {"error": "Nenhum objeto detectado", "items": []}
+
+#     # 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)})
+
+#     if not candidates:
+#         return {"error": "Somente ruído encontrado abaixo do min_area", "items": []}
+
+#     # 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])
+
+#     candidates = candidates[:max_items]
+
+#     # 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)
+
+#         # acumula totais
+#         total_pixels_sum += r["total_pixels"]
+#         corrosion_pixels_sum += r["corrosion_pixels"]
+
+#         # 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 {
+#         "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(...),
+#     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_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)
+
+# @app.get("/")
+# def read_root():
+#     return {"status": "ok"}
+