fix: rename requirements_hf.txt to requirements.txt

app.py

@@ -1,7 +1,5 @@
 """
-app.py — TrackIQ Backend (v5 — COMPLET avec Dashboard + Logs + History)
-CORRECTIONS v10: /api/logs/rows, DELETE /api/logs/clear, format CSV prof,
-                 unique tracking, counts dans /api/history
+app.py — TrackIQ Backend (v6 — CORRIGÉ : Human/Person, CONF, modèle)
 """
 import cv2, csv, json, threading, queue, uuid, mimetypes, subprocess, io
 from pathlib import Path
@@ -18,45 +16,46 @@ from ultralytics import YOLO
 app = Flask(__name__, static_folder="static", template_folder="templates")
 CORS(app)
 
-BASE       = Path(__file__).parent
-UPLOAD_DIR = BASE / "uploads";  UPLOAD_DIR.mkdir(exist_ok=True)
-OUTPUT_DIR = BASE / "outputs";  OUTPUT_DIR.mkdir(exist_ok=True)
-LOG_DIR    = BASE / "logs";     LOG_DIR.mkdir(exist_ok=True)
-MODELS_DIR = BASE / "models";   MODELS_DIR.mkdir(exist_ok=True)
+BASE = Path(__file__).parent
+UPLOAD_DIR = BASE / "uploads"; UPLOAD_DIR.mkdir(exist_ok=True)
+OUTPUT_DIR = BASE / "outputs"; OUTPUT_DIR.mkdir(exist_ok=True)
+LOG_DIR    = BASE / "logs";    LOG_DIR.mkdir(exist_ok=True)
+MODELS_DIR = BASE / "models";  MODELS_DIR.mkdir(exist_ok=True)
 
-# Mapping COCO réel → nom affiché
+# ── CORRECTION 1 : "Person" → "Human" pour matcher l'UI ─────────────────────
+# Mapping COCO réel → nom affiché (index COCO officiel)
 COCO_TO_LABEL = {
-    0:  "Person",
-    1:  "Bicycle",
-    2:  "Vehicle",
-    3:  "Motorcycle",
-    5:  "Bus",
-    7:  "Truck",
-    9:  "Traffic light",
+    0: "Human",        # ← WAS "Person" — doit correspondre à ce que l'UI envoie
+    1: "Bicycle",
+    2: "Vehicle",
+    3: "Motorcycle",
+    5: "Bus",
+    7: "Truck",
+    9: "Traffic light",
     11: "Road sign",
 }
-# Remap Person → Human pour cohérence avec le frontend
-LABEL_REMAP     = {"Person": "Human"}
-DEFAULT_CLASSES = ["Vehicle","Motorcycle","Truck","Bus","Human","Bicycle","Traffic light","Road sign"]
+DEFAULT_CLASSES = list(COCO_TO_LABEL.values())
+
 CLASS_COLORS = {
-    "Vehicle":       (255,120,80),
-    "Motorcycle":    (80, 200,80),
-    "Truck":         (0,  180,255),
-    "Bus":           (220,80, 255),
-    "Human":         (236,72, 153),
-    "Bicycle":       (6,  182,212),
-    "Traffic light": (239,68, 68),
-    "Road sign":     (249,115,22),
+    "Vehicle":       (255, 120, 80),
+    "Motorcycle":    (80,  200, 80),
+    "Truck":         (0,   180, 255),
+    "Bus":           (220, 80,  255),
+    "Human":         (236, 72,  153),   # ← WAS "Person"
+    "Bicycle":       (6,   182, 212),
+    "Traffic light": (239, 68,  68),
+    "Road sign":     (249, 115, 22),
 }
 
-CONF     = 0.40
+# ── CORRECTION 2 : seuil de confiance abaissé + résolution augmentée ─────────
+CONF     = 0.25   # ← WAS 0.40  (trop élevé pour webcam intérieure)
 IOU      = 0.45
-SKIP     = 2          # traiter 1 frame sur (SKIP+1) pour la vitesse
-INFER_SZ = 320
+SKIP     = 1
+INFER_SZ = 640    # ← WAS 320   (plus de précision)
 
-_jobs: Dict[str,dict] = {}
-_sse_queues: Dict[str,queue.Queue] = {}
-_stats_lock  = threading.Lock()
+_jobs: Dict[str, dict] = {}
+_sse_queues: Dict[str, queue.Queue] = {}
+_stats_lock = threading.Lock()
 _global_stats = {
     "total_frames":        0,
     "total_detections":    0,
@@ -64,20 +63,15 @@ _global_stats = {
     "scenes":              []
 }
 
-# FIX: stockage des rows détaillées (format prof) en mémoire
-_log_rows      = []
-_log_rows_lock = threading.Lock()
-
 # ── Webcam state ──────────────────────────────────────────────────────────────
-_webcam_active              = False
-_webcam_classes             = []
-_webcam_frame_count         = 0
-_webcam_detections          = 0
+_webcam_active            = False
+_webcam_classes           = []
+_webcam_frame_count       = 0
+_webcam_detections        = 0
 _webcam_detections_by_class = defaultdict(int)
-_webcam_unique_ids          = defaultdict(set)
-_webcam_lock                = threading.Lock()
+_webcam_lock              = threading.Lock()
 
-# ── Model ─────────────────────────────────────────────────────────────────────
+# ── Chargement du modèle en arrière-plan ──────────────────────────────────────
 _model       = None
 _model_ready = False
 
@@ -88,71 +82,81 @@ def _load_model_background():
     _model_ready = True
     print("✅ Modèle YOLO chargé !")
 
-def _get_model(key="yolo11n"):
+# ── CORRECTION 3 : utiliser yolov8n (plus stable sur HuggingFace Spaces) ─────
+def _get_model(key="yolov8n"):   # ← WAS "yolo11n" (moins fiable sur HF)
     p = MODELS_DIR / f"{key}.pt"
     if not p.exists():
         m = YOLO(f"{key}.pt")
         import shutil
         dl = Path(f"{key}.pt")
-        if dl.exists(): shutil.move(str(dl), str(p))
+        if dl.exists():
+            shutil.move(str(dl), str(p))
         return m
     return YOLO(str(p))
 
+# Lancer le chargement dès le démarrage
 threading.Thread(target=_load_model_background, daemon=True).start()
 
-# ── Helpers ───────────────────────────────────────────────────────────────────
-def _coco_to_frontend(cls_idx):
-    name = COCO_TO_LABEL.get(cls_idx)
-    if name is None:
-        return None
-    return LABEL_REMAP.get(name, name)
-
+# ── Fonction utilitaire pour dessiner les détections ──────────────────────────
 def _draw_detections(frame, results, classes_filter=None):
+    """Dessine les boîtes de détection sur le frame"""
     detection_count = 0
+
     if results and results[0].boxes:
         boxes = results[0].boxes
         for box in boxes:
-            cls        = int(box.cls[0])
-            conf       = float(box.conf[0])
-            class_name = _coco_to_frontend(cls)
+            cls  = int(box.cls[0])
+            conf = float(box.conf[0])
+
+            class_name = COCO_TO_LABEL.get(cls)
             if class_name is None:
                 continue
+
             if classes_filter and class_name not in classes_filter:
                 continue
+
             detection_count += 1
-            x1,y1,x2,y2 = map(int, box.xyxy[0])
-            color = CLASS_COLORS.get(class_name, (255,255,255))
+            x1, y1, x2, y2 = map(int, box.xyxy[0])
+            color = CLASS_COLORS.get(class_name, (255, 255, 255))
             label = f"{class_name} {conf:.2f}"
-            cv2.rectangle(frame, (x1,y1), (x2,y2), color, 2)
-            cv2.putText(frame, label, (x1, max(y1-5,0)),
+            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+            cv2.putText(frame, label, (x1, y1 - 5),
                         cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
     return frame, detection_count
 
-# ── Pages HTML ────────────────────────────────────────────────────────────────
+# ── Routes HTML ───────────────────────────────────────────────────────────────
+
 @app.route("/")
-def index(): return render_template("index.html")
+def index():
+    return render_template("index.html")
 
 @app.route("/home")
-def home(): return render_template("home.html")
+def home():
+    return render_template("home.html")
 
 @app.route("/dashboard")
-def dashboard(): return render_template("dashboard.html")
+def dashboard():
+    return render_template("dashboard.html")
 
 @app.route("/history")
-def history(): return render_template("history.html")
+def history():
+    return render_template("history.html")
 
 @app.route("/logs")
-def logs(): return render_template("logs.html")
+def logs():
+    return render_template("logs.html")
 
 @app.route("/static/<path:filename>")
-def serve_static(filename): return send_from_directory("static", filename)
+def serve_static(filename):
+    return send_from_directory("static", filename)
+
+# ── API Routes ────────────────────────────────────────────────────────────────
 
-# ── Health ────────────────────────────────────────────────────────────────────
 @app.route("/health")
 def health():
     return jsonify({"status": "ok", "model_ready": _model_ready}), 200
 
-# ── Upload ────────────────────────────────────────────────────────────────────
 @app.route("/api/upload", methods=["POST"])
 def api_upload():
     if "video" not in request.files:
@@ -166,12 +170,10 @@ def api_upload():
         "path":       str(dest),
         "name":       f.filename,
         "detections": defaultdict(int),
-        "frames":     0,
-        "classes":    DEFAULT_CLASSES,
+        "frames":     0
     }
     return jsonify({"job_id": jid})
 
-# ── Run ───────────────────────────────────────────────────────────────────────
 @app.route("/api/run", methods=["POST"])
 def api_run():
     data = request.json or {}
@@ -180,181 +182,60 @@ def api_run():
         return jsonify({"error": "Unknown job_id"}), 404
     if not _model_ready:
         return jsonify({"error": "Model not ready yet, please wait"}), 503
-    _jobs[jid]["classes"] = data.get("classes", DEFAULT_CLASSES)
-    _sse_queues[jid] = queue.Queue(maxsize=300)
     threading.Thread(target=_worker, args=(jid,), daemon=True).start()
     return jsonify({"status": "started"})
 
-# ── Worker ────────────────────────────────────────────────────────────────────
 def _worker(jid):
-    global _log_rows
-    job         = _jobs[jid]
+    global _global_stats
+    job = _jobs[jid]
     job["status"] = "running"
-    q           = _sse_queues[jid]
-    path        = job["path"]
-    video_name  = job["name"]
-    sel_classes = job.get("classes", DEFAULT_CLASSES)
-    scene_name  = Path(video_name).stem or jid
-
-    cap   = cv2.VideoCapture(path)
-    fps   = cap.get(cv2.CAP_PROP_FPS) or 30
-    W     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    H     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1
-
-    unique_ids = defaultdict(set)   # FIX: track unique IDs per class
-    hist_xy    = defaultdict(list)  # FIX: history for direction/speed
-    timeline   = []
-    new_rows   = []
-    frame_id   = 0
+
+    cap         = cv2.VideoCapture(job["path"])
+    frame_count = 0
 
     while True:
         ret, frame = cap.read()
         if not ret:
             break
-        frame_id += 1
-        if frame_id % (SKIP + 1) != 0:
-            continue
+        frame_count += 1
+        results = _model(frame, conf=CONF, iou=IOU, imgsz=INFER_SZ, verbose=False)
 
-        ts = round(frame_id / fps, 3)
-
-        # FIX: persist=True pour IDs stables entre frames
-        results = _model.track(frame, conf=CONF, iou=IOU, imgsz=INFER_SZ,
-                               persist=True, verbose=False)
-
-        frame_counts = defaultdict(int)
-        if results[0].boxes is not None:
-            boxes    = results[0].boxes
-            has_ids  = boxes.id is not None
-            for i, box in enumerate(boxes):
+        if results[0].boxes:
+            for box in results[0].boxes:
                 cls        = int(box.cls[0])
-                class_name = _coco_to_frontend(cls)
-                if not class_name or class_name not in sel_classes:
-                    continue
-                conf_val = float(box.conf[0])
-                x1,y1,x2,y2 = map(int, box.xyxy[0])
-                cx = (x1+x2)//2
-                cy = (y1+y2)//2
-                tid = int(boxes.id[i]) if has_ids else -1
-                unique_ids[class_name].add(tid)
-                frame_counts[class_name] += 1
-
-                # Direction & speed
-                h = hist_xy[tid]
-                h.append((cx,cy))
-                direction  = "unknown"
-                speed_px_s = 0.0
-                if len(h) >= 2:
-                    dx = h[-1][0]-h[-2][0]
-                    dy = h[-1][1]-h[-2][1]
-                    dist = (dx**2+dy**2)**0.5
-                    speed_px_s = round(dist*fps/(SKIP+1), 2)
-                    direction = ("right" if dx>0 else "left") if abs(dx)>abs(dy) else ("down" if dy>0 else "up")
-
-                # FIX: format CSV du prof
-                new_rows.append({
-                    "scene_id":     jid,
-                    "scene_name":   scene_name,
-                    "video_name":   video_name,
-                    "frame_id":     frame_id,
-                    "timestamp_s":  ts,
-                    "track_id":     tid,
-                    "class_name":   class_name,
-                    "confidence":   round(conf_val, 4),
-                    "x1":x1,"y1":y1,"x2":x2,"y2":y2,
-                    "cx":cx,"cy":cy,
-                    "frame_width":  W,
-                    "frame_height": H,
-                    "direction":    direction,
-                    "speed_px_s":   speed_px_s,
-                    "crossed_line": False,
-                })
-
-        timeline.append({"frame":frame_id,"ts":round(frame_id/fps,2),**dict(frame_counts)})
-        uc = {k:len(v) for k,v in unique_ids.items()}
-        pct = min(99.0, frame_id/total*100)
-        try:
-            q.put_nowait({
-                "event": "progress", "pct": round(pct,1),
-                "frame": frame_id, "total": total,
-                "unique_counts": uc, "no_objects": len(frame_counts)==0,
-                "hud": {"frame_str": f"F:{frame_id}/{total}", "counts": dict(frame_counts)},
-            })
-        except queue.Full:
-            pass
+                class_name = COCO_TO_LABEL.get(cls)
+                if class_name:
+                    job["detections"][class_name] = job["detections"].get(class_name, 0) + 1
 
     cap.release()
-
-    with _log_rows_lock:
-        _log_rows.extend(new_rows)
-
-    final_unique = {k:len(v) for k,v in unique_ids.items()}
-    stats = {
-        "total_frames":  frame_id,
-        "total_unique":  sum(final_unique.values()),
-        "fps":           round(fps,1),
-        "duration_s":    round(frame_id/fps,1),
-        "unique_counts": final_unique,
-        "video_name":    video_name,
-        "scene_name":    scene_name,
-        "timeline":      timeline,
-    }
     job["status"] = "done"
-    job["frames"] = frame_id
-    job["detections"] = final_unique
-    job["stats"] = stats
-
-    try: q.put_nowait({"event":"done","stats":stats})
-    except queue.Full: pass
+    job["frames"]  = frame_count
 
     with _stats_lock:
-        _global_stats["total_frames"]     += frame_id
-        _global_stats["total_detections"] += sum(final_unique.values())
-        for cls,cnt in final_unique.items():
+        _global_stats["total_frames"]      += frame_count
+        _global_stats["total_detections"]  += sum(job["detections"].values())
+        for cls, cnt in job["detections"].items():
             _global_stats["detections_by_class"][cls] += cnt
+
         _global_stats["scenes"].append({
-            "scene_id":      jid,
-            "scene_name":    scene_name,
-            "video_name":    video_name,
-            "frames":        frame_id,
-            "total":         sum(final_unique.values()),
-            "unique_counts": final_unique,
-            "generated_at":  datetime.now().isoformat(),
-            "duration_s":    round(frame_id/fps,1),
-            "fps":           round(fps,1),
-            "timeline":      timeline,
+            "scene_id":     jid,
+            "video_name":   job["name"],
+            "frames":       frame_count,
+            "total":        sum(job["detections"].values()),
+            "unique_counts": dict(job["detections"]),
+            "generated_at": datetime.now().isoformat(),
+            "duration_s":   frame_count / 30
         })
 
-# ── SSE ───────────────────────────────────────────────────────────────────────
-@app.route("/api/stream/<jid>")
-def api_stream(jid):
-    if jid not in _jobs:
-        return jsonify({"error":"not found"}),404
-    def generate():
-        import time
-        deadline=time.time()+15
-        while jid not in _sse_queues:
-            if time.time()>deadline: yield 'data:{"event":"error"}\n\n'; return
-            time.sleep(0.05)
-        q=_sse_queues[jid]
-        while True:
-            try:
-                item=q.get(timeout=60)
-                yield f"data:{json.dumps(item)}\n\n"
-                if item.get("event")=="done": break
-            except: break
-    return Response(stream_with_context(generate()),
-                    mimetype="text/event-stream",
-                    headers={"Cache-Control":"no-cache","X-Accel-Buffering":"no"})
-
-# ── Status ────────────────────────────────────────────────────────────────────
 @app.route("/api/status/<jid>")
 def api_status(jid):
-    job=_jobs.get(jid)
-    if not job: return jsonify({"error":"not found"}),404
-    return jsonify({"status":job["status"],"stats":job.get("stats",{}),"frames":job.get("frames",0)})
+    job = _jobs.get(jid)
+    if not job:
+        return jsonify({"error": "not found"}), 404
+    return jsonify({"status": job["status"]})
 
 # ── Dashboard ─────────────────────────────────────────────────────────────────
+
 @app.route("/api/dashboard/stats")
 def api_dashboard_stats():
     with _stats_lock:
@@ -362,147 +243,138 @@ def api_dashboard_stats():
             "global_unique_counts": dict(_global_stats["detections_by_class"]),
             "scenes":               _global_stats["scenes"],
             "total_frames":         _global_stats["total_frames"],
-            "total_detections":     _global_stats["total_detections"],
-        }),200
+            "total_detections":     _global_stats["total_detections"]
+        }), 200
 
 # ── Logs ──────────────────────────────────────────────────────────────────────
+
 @app.route("/api/logs")
 def api_logs():
     with _stats_lock:
-        return jsonify(_global_stats["scenes"]),200
-
-# FIX: route /api/logs/rows — retourne toutes les rows détaillées
-@app.route("/api/logs/rows")
-def api_logs_rows():
-    scene_id = request.args.get("scene_id")
-    with _log_rows_lock:
-        rows = [r for r in _log_rows if r["scene_id"]==scene_id] if scene_id else list(_log_rows)
-    return jsonify(rows),200
-
-# FIX: DELETE /api/logs/clear — vide tout
-@app.route("/api/logs/clear", methods=["DELETE"])
-def api_logs_clear():
-    with _stats_lock:
-        _global_stats["scenes"].clear()
-        _global_stats["total_frames"]     = 0
-        _global_stats["total_detections"] = 0
-        _global_stats["detections_by_class"].clear()
-    with _log_rows_lock:
-        _log_rows.clear()
-    return jsonify({"status":"cleared"}),200
-
-# FIX: DELETE /api/logs/<scene_id> — supprime une scène
-@app.route("/api/logs/<scene_id>", methods=["DELETE"])
-def api_logs_delete(scene_id):
-    with _stats_lock:
-        _global_stats["scenes"] = [s for s in _global_stats["scenes"] if s["scene_id"]!=scene_id]
-    with _log_rows_lock:
-        before = len(_log_rows)
-        _log_rows[:] = [r for r in _log_rows if r["scene_id"]!=scene_id]
-    return jsonify({"deleted": before-len(_log_rows)}),200
+        return jsonify(_global_stats["scenes"]), 200
 
-# FIX: CSV format prof
 @app.route("/api/logs/<scene_id>/csv")
 def api_logs_csv(scene_id):
-    with _log_rows_lock:
-        rows = [r for r in _log_rows if r["scene_id"]==scene_id]
-    out = io.StringIO()
-    w   = csv.writer(out)
-    # En-têtes format prof
-    w.writerow(["frame","timestamp_sec","scene_name","group_id","video_name",
-                "track_id","class_name","confidence",
-                "bbox_x1","bbox_y1","bbox_x2","bbox_y2",
-                "cx","cy","frame_width","frame_height",
-                "crossed_line","direction","speed_px_s"])
-    for r in rows:
-        w.writerow([r["frame_id"],r["timestamp_s"],r["scene_name"],scene_id,
-                    r["video_name"],r["track_id"],r["class_name"],r["confidence"],
-                    r["x1"],r["y1"],r["x2"],r["y2"],
-                    r["cx"],r["cy"],r.get("frame_width",0),r.get("frame_height",0),
-                    r.get("crossed_line",False),r["direction"],r["speed_px_s"]])
-    return Response(out.getvalue(), mimetype="text/csv",
-                    headers={"Content-Disposition":f"attachment;filename={scene_id}_logs.csv"})
+    job = _jobs.get(scene_id)
+    if not job:
+        return jsonify({"error": "not found"}), 404
+
+    output = io.StringIO()
+    writer = csv.writer(output)
+    writer.writerow(["scene_id", "video_name", "class_name", "count",
+                     "generated_at", "total_frames"])
+    for class_name, count in job.get("detections", {}).items():
+        writer.writerow([scene_id, job["name"], class_name, count,
+                         datetime.now().isoformat(), job.get("frames", 0)])
+
+    return Response(
+        output.getvalue(),
+        mimetype="text/csv",
+        headers={"Content-Disposition": f"attachment;filename={scene_id}_logs.csv"}
+    ), 200
 
 # ── History ───────────────────────────────────────────────────────────────────
+
 @app.route("/api/history")
 def api_history():
     with _stats_lock:
-        return jsonify([{
-            "name":   s["video_name"],
-            "url":    f"/api/logs/{s['scene_id']}/csv",
-            "date":   s["generated_at"],
-            "counts": s.get("unique_counts",{}),   # FIX: inclus pour le HUD history.html
-        } for s in reversed(_global_stats["scenes"])]),200
-
-# ── Webcam routes ─────────────────────────────────────────────────────────────
+        history = []
+        for scene in _global_stats["scenes"]:
+            history.append({
+                "name": scene["video_name"],
+                "url":  f"/api/logs/{scene['scene_id']}/csv",
+                "date": scene["generated_at"]
+            })
+        return jsonify(history), 200
+
+# ── Webcam ────────────────────────────────────────────────────────────────────
+
 @app.route("/api/webcam/start", methods=["POST"])
 def api_webcam_start():
-    global _webcam_active,_webcam_classes,_webcam_frame_count,_webcam_detections,_webcam_detections_by_class,_webcam_unique_ids
-    data=request.json or {}
-    if not _model_ready: return jsonify({"error":"Model not ready"}),503
+    global _webcam_active, _webcam_classes, _webcam_frame_count
+    global _webcam_detections, _webcam_detections_by_class
+
+    data    = request.json or {}
+    classes = data.get("classes", DEFAULT_CLASSES)
+
+    if not _model_ready:
+        return jsonify({"error": "Model not ready"}), 503
+
     with _webcam_lock:
-        _webcam_active=True
-        _webcam_classes=data.get("classes",DEFAULT_CLASSES)
-        _webcam_frame_count=0
-        _webcam_detections=0
-        _webcam_detections_by_class=defaultdict(int)
-        _webcam_unique_ids=defaultdict(set)
-    return jsonify({"status":"started"}),200
+        _webcam_active              = True
+        _webcam_classes             = classes
+        _webcam_frame_count         = 0
+        _webcam_detections          = 0
+        _webcam_detections_by_class = defaultdict(int)
+
+    print(f"✅ Webcam started with classes: {classes}")
+    return jsonify({"status": "started"}), 200
 
 @app.route("/api/webcam/frame", methods=["POST"])
 def api_webcam_frame():
-    global _webcam_frame_count,_webcam_detections,_webcam_detections_by_class,_webcam_unique_ids
+    global _webcam_frame_count, _webcam_detections, _webcam_detections_by_class
+
     if not _webcam_active or not _model_ready:
-        return jsonify({"error":"Webcam not active"}),503
+        return jsonify({"error": "Webcam not active"}), 503
+
     try:
-        nparr = np.frombuffer(request.data, np.uint8)
+        img_data = request.data
+        if not img_data:
+            return jsonify({"error": "No image data"}), 400
+
+        nparr = np.frombuffer(img_data, np.uint8)
         frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-        if frame is None: return jsonify({"error":"Decode failed"}),400
-        # FIX: persist=True pour IDs stables webcam
-        results = _model.track(frame, conf=CONF, iou=IOU, imgsz=INFER_SZ,
-                               persist=True, verbose=False)
-        annotated, det_count = _draw_detections(frame, results, _webcam_classes)
+
+        if frame is None:
+            return jsonify({"error": "Could not decode image"}), 400
+
+        # Inférence YOLO avec les paramètres corrigés
+        results = _model(frame, conf=CONF, iou=IOU, imgsz=INFER_SZ, verbose=False)
+
+        annotated, detection_count = _draw_detections(frame, results, _webcam_classes)
+
         with _webcam_lock:
-            _webcam_frame_count += 1
-            _webcam_detections  += det_count
-            if results[0].boxes is not None:
-                boxes   = results[0].boxes
-                has_ids = boxes.id is not None
-                for i,box in enumerate(boxes):
-                    cls=int(box.cls[0])
-                    cn=_coco_to_frontend(cls)
-                    if cn and cn in _webcam_classes:
-                        _webcam_detections_by_class[cn] += 1
-                        if has_ids:
-                            _webcam_unique_ids[cn].add(int(boxes.id[i]))
-        _,buf=cv2.imencode('.jpg', annotated)
-        return Response(buf.tobytes(), mimetype='image/jpeg'),200
+            _webcam_frame_count  += 1
+            _webcam_detections   += detection_count
+
+            if results[0].boxes:
+                for box in results[0].boxes:
+                    cls        = int(box.cls[0])
+                    class_name = COCO_TO_LABEL.get(cls)
+                    if class_name and class_name in _webcam_classes:
+                        _webcam_detections_by_class[class_name] += 1
+
+        ret, buffer = cv2.imencode('.jpg', annotated)
+        return Response(buffer.tobytes(), mimetype='image/jpeg'), 200
+
     except Exception as e:
-        return jsonify({"error":str(e)}),500
+        print(f"❌ Webcam frame error: {e}")
+        return jsonify({"error": str(e)}), 500
 
 @app.route("/api/webcam/stop", methods=["POST"])
 def api_webcam_stop():
     global _webcam_active
-    with _webcam_lock: _webcam_active=False
-    return jsonify({"status":"stopped"}),200
+    with _webcam_lock:
+        _webcam_active = False
+    print("⏹️ Webcam stopped")
+    return jsonify({"status": "stopped"}), 200
 
 @app.route("/api/webcam/stats")
 def api_webcam_stats():
     with _webcam_lock:
-        by_class    = dict(_webcam_detections_by_class)
-        unique_only = {k:len(v) for k,v in _webcam_unique_ids.items()}
-        # FIX: current_counts = objets dans le frame actuel (unique_only ici)
+        by_class = dict(_webcam_detections_by_class)
         return jsonify({
-            "active":              _webcam_active,
-            "frame":               _webcam_frame_count,
-            "detections":          _webcam_detections,
-            "detections_by_class": by_class,
-            "frame_counts":        unique_only,   # live count par classe
-            "unique_counts":       unique_only,   # alias
-        }),200
+            "active":               _webcam_active,
+            "frame":                _webcam_frame_count,
+            "detections":           _webcam_detections,
+            "detections_by_class":  by_class,
+            "frame_counts":         by_class,
+            "unique_counts":        by_class
+        }), 200
 
 # ── Main ──────────────────────────────────────────────────────────────────────
+
 if __name__ == "__main__":
     import os
     port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False)
+    app.run(host="0.0.0.0", port=port, debug=False)