Upload Dockerfile and main.py

Dockerfile

@@ -0,0 +1,21 @@
+# Usa uma imagem oficial do Python otimizada
+FROM python:3.11-slim
+
+# Instala dependências do Linux necessárias para o OpenCV e YOLO rodarem sem quebrar
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Cria e define a pasta de trabalho dentro do servidor
+WORKDIR /code
+
+# Copia o arquivo de requisitos e instala as bibliotecas
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copia todo o resto do seu código e a pasta weights para o servidor
+COPY . .
+
+# Comando padrão para iniciar a API dentro do Hugging Face usando a porta 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,135 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from ultralytics import YOLO
+from PIL import Image
+import io
+import numpy as np
+
+app = FastAPI(title="YOLO Custom API - Gadoline")
+
+# Configuração de CORS para permitir requisições da sua aplicação Web
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# =========================================================
+# CONFIGURAÇÕES ADAPTADAS DO SEU COLAB
+# =========================================================
+# Lembre-se de colocar o arquivo "best.pt" dentro da pasta weights do seu projeto!
+MODEL_PATH = "weights/best.pt" 
+CONFIDENCE_THRESHOLD = 0.1
+IMG_SIZE = 640
+MIN_SIZE = 5
+MAX_SIZE = 500
+IOU_THRESHOLD = 0.70
+
+# Carrega o modelo localmente
+model = YOLO(MODEL_PATH)
+
+# =========================================================
+# FUNÇÕES MATEMÁTICAS (IoU e Merge)
+# =========================================================
+def calculate_iou(boxA, boxB):
+    xA = max(boxA[0], boxB[0])
+    yA = max(boxA[1], boxB[1])
+    xB = min(boxA[2], boxB[2])
+    yB = min(boxA[3], boxB[3])
+
+    inter_w = max(0, xB - xA)
+    inter_h = max(0, yB - yA)
+    inter_area = inter_w * inter_h
+
+    if inter_area == 0:
+        return 0.0
+
+    areaA = (boxA[2] - boxA[0]) * (boxA[3] - boxA[1])
+    areaB = (boxB[2] - boxB[0]) * (boxB[3] - boxB[1])
+    union = areaA + areaB - inter_area
+
+    return inter_area / union
+
+def merge_overlapping_boxes(boxes, iou_threshold=0.93):
+    merged = []
+    boxes = sorted(boxes, key=lambda x: x["conf"], reverse=True)
+
+    while boxes:
+        current = boxes.pop(0)
+        new_boxes = []
+
+        for other in boxes:
+            iou = calculate_iou(current["coords"], other["coords"])
+            if iou >= iou_threshold:
+                x1 = int((current["coords"][0] + other["coords"][0]) / 2)
+                y1 = int((current["coords"][1] + other["coords"][1]) / 2)
+                x2 = int((current["coords"][2] + other["coords"][2]) / 2)
+                y2 = int((current["coords"][3] + other["coords"][3]) / 2)
+
+                current["coords"] = [x1, y1, x2, y2]
+                current["conf"] = max(current["conf"], other["conf"])
+            else:
+                new_boxes.append(other)
+
+        merged.append(current)
+        boxes = new_boxes
+
+    return merged
+
+# =========================================================
+# ENDPOINT DE PREDIÇÃO
+# =========================================================
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    # 1. Recebe a imagem enviada pela aplicação web
+    image_bytes = await file.read()
+    image = Image.open(io.BytesIO(image_bytes))
+
+    # 2. Executa a inferência forçando o tamanho 640 e os parâmetros do Colab
+    results = model.predict(
+        source=image,
+        imgsz=IMG_SIZE,
+        conf=CONFIDENCE_THRESHOLD,
+        device="cpu",
+        verbose=False
+    )
+
+    boxes_data = []
+
+    # 3. Varre os resultados aplicando os filtros
+    for r in results:
+        if r.boxes:
+            for box in r.boxes:
+                cls = int(box.cls[0])
+
+                # Filtro de classe: Apenas classe 0 (igual ao seu Colab)
+                if cls != 0:
+                    continue
+
+                xyxy = box.xyxy[0].cpu().numpy().astype(int)
+                x1, y1, x2, y2 = xyxy
+                conf = float(box.conf[0])
+
+                w = x2 - x1
+                h = y2 - y1
+
+                # Filtro de tamanho mínimo e máximo
+                if not ((MIN_SIZE <= w <= MAX_SIZE) and (MIN_SIZE <= h <= MAX_SIZE)):
+                    continue
+
+                boxes_data.append({
+                    "coords": [int(x1), int(y1), int(x2), int(y2)],
+                    "conf": conf,
+                    "cls": cls
+                })
+
+    # 4. Remove duplicadas usando o seu filtro IoU
+    filtered_boxes = merge_overlapping_boxes(boxes_data, iou_threshold=IOU_THRESHOLD)
+
+    # 5. Retorna o JSON limpo e idêntico ao esperado pelo seu front-end
+    return {
+        "total_detections": len(filtered_boxes),
+        "predictions": filtered_boxes
+    }