Update app.py

app.py

@@ -1,14 +1,15 @@
 from fastapi import FastAPI, File, UploadFile
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-import torch
 from PIL import Image
-from transformers import AutoImageProcessor, AutoBackbone
 import io
+import torch
 import numpy as np
+from transformers import AutoImageProcessor, AutoBackbone
 
 app = FastAPI(title="FAST TextNet API")
 
+# --- Autoriser Flutter / navigateur ---
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -16,71 +17,76 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# --- Chargement modèle ---
 print("Chargement du modèle...")
 processor = AutoImageProcessor.from_pretrained("czczup/textnet-base")
 model = AutoBackbone.from_pretrained("czczup/textnet-base")
 model.eval()
 print("Modèle prêt !")
 
+# --- Health check ---
 @app.get("/")
 def health():
     return {"status": "ok", "model": "czczup/textnet-base"}
 
+# --- Détection texte ---
 @app.post("/detect")
 async def detect_text(file: UploadFile = File(...)):
     try:
+        # Lire image
         image_bytes = await file.read()
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
 
+        # Préparer entrée modèle
         inputs = processor(image, return_tensors="pt")
 
+        # Inference
         with torch.no_grad():
             outputs = model(**inputs)
 
-        # Récupère tous les feature maps
-        feature_maps = []
-        for fm in outputs.feature_maps:
-            feature_maps.append({
-                "shape": list(fm.shape),
-                "mean": float(fm.mean()),
-                "std": float(fm.std()),
-                "min": float(fm.min()),
-                "max": float(fm.max()),
-            })
-
-        
+        # --- Post-processing simple ---
         # On prend la dernière feature map
         fm = outputs.feature_maps[-1][0]  # shape: [C, H, W]
-        
-        # On fait une "heatmap" simple
         heatmap = fm.mean(dim=0).numpy()
-        
+
+        H, W = heatmap.shape
         threshold = heatmap.max() * 0.5
-        
+
+        # Extraire points chauds
+        points = [(x, y) for y in range(H) for x in range(W) if heatmap[y, x] > threshold]
+
+        # Regrouper par ligne (simple)
+        lines = {}
+        for (x, y) in points:
+            key = int(y / 10)  # regroupe tous les y proches
+            if key not in lines:
+                lines[key] = []
+            lines[key].append((x, y))
+
+        # Générer les boxes
+        scale_x = image.width / W
+        scale_y = image.height / H
+
         boxes = []
-        
-        H, W = heatmap.shape
+        for line in lines.values():
+            xs = [p[0] for p in line]
+            ys = [p[1] for p in line]
+            min_x, max_x = min(xs), max(xs)
+            min_y, max_y = min(ys), max(ys)
+
+            # Filtre petites boxes
+            if (max_x - min_x) < 5 or (max_y - min_y) < 2:
+                continue
+
+            boxes.append({
+                "x": int(min_x * scale_x),
+                "y": int(min_y * scale_y),
+                "w": int((max_x - min_x) * scale_x),
+                "h": int((max_y - min_y) * scale_y),
+                "text": "ligne détectée"
+            })
 
-        print("Heatmap min:", heatmap.min())
-        print("Heatmap max:", heatmap.max())
-        print("Threshold:", threshold)
-
-        print("Feature maps:", len(outputs.feature_maps))
-        print("Shape:", outputs.feature_maps[-1].shape)
-
-        
-        for y in range(0, H, 5):
-            for x in range(0, W, 5):
-                if heatmap[y, x] > threshold:
-                    boxes.append({
-                        "x": int(x * 4),
-                        "y": int(y * 4),
-                        "w": 40,
-                        "h": 20,
-                        "text": "text"
-                    })
-        
-        return boxes
+        return JSONResponse(boxes)
 
     except Exception as e:
-        return JSONResponse({"success": False, "error": str(e)}, status_code=500)
+        return JSONResponse({"success": False, "error": str(e)}, status_code=500)