add

backend/main.py

@@ -6,6 +6,7 @@ Processes frames as fast as possible; frontend controls playback timing.
 import asyncio
 import base64
 import json
+import re
 import shutil
 import subprocess
 import time
@@ -17,6 +18,7 @@ from collections import defaultdict, deque
 from pathlib import Path
 
 import cv2
+import numpy as np
 from fastapi import FastAPI, File, Form, UploadFile, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, StreamingResponse
@@ -45,6 +47,8 @@ if STATIC_DIR.exists():
 
 # ─── Session store ─────────────────────────────────────────────────────────────
 sessions: dict[str, dict] = {}
+webcam_sessions: dict[str, dict] = {}
+scene_lock = threading.Lock()
 
 
 def _safe_log_path(filename: str) -> Path:
@@ -57,6 +61,8 @@ def _safe_log_path(filename: str) -> Path:
 def _get_summary_for_session(sid: str) -> dict | None:
     if sid in sessions:
         return sessions[sid].get("summary")
+    if sid in webcam_sessions:
+        return webcam_sessions[sid].get("summary")
 
     for summary_path in LOG_DIR.glob("*_summary.json"):
         try:
@@ -80,6 +86,41 @@ def _get_completed_session_summary(sid: str) -> dict:
     return summary
 
 
+def _iter_known_scene_names(group_id: str):
+    for session in sessions.values():
+        if session.get("group_id") == group_id and session.get("scene_name"):
+            yield session["scene_name"]
+    for session in webcam_sessions.values():
+        if session.get("group_id") == group_id and session.get("scene_name"):
+            yield session["scene_name"]
+    for summary_path in LOG_DIR.glob("*_summary.json"):
+        try:
+            summary = json.loads(summary_path.read_text())
+        except Exception:
+            continue
+        if summary.get("group_id") == group_id and summary.get("scene"):
+            yield summary["scene"]
+
+
+def _next_scene_name(requested_scene: str, group_id: str) -> str:
+    requested = (requested_scene or "scene").strip() or "scene"
+    exact_exists = any(scene_name == requested for scene_name in _iter_known_scene_names(group_id))
+    suffix_match = re.match(r"^(.+?)_(\d{2,})$", requested)
+    base = suffix_match.group(1) if exact_exists and suffix_match else requested
+    scene_pattern = re.compile(rf"^{re.escape(base)}(?:_(\d{{2,}}))?$")
+    order_numbers = []
+
+    for scene_name in _iter_known_scene_names(group_id):
+        match = scene_pattern.match(scene_name)
+        if not match:
+            continue
+        order_numbers.append(int(match.group(1) or 0))
+
+    if not order_numbers:
+        return base
+    return f"{base}_{max(order_numbers) + 1:02d}"
+
+
 def _ensure_browser_compatible_video(video_path: str) -> str:
     """
     OpenCV's mp4v output downloads fine, but many browsers will not play it in
@@ -176,20 +217,22 @@ async def upload_video(
 
     selected = [c.strip() for c in classes.split(",") if c.strip()] or DEFAULT_CLASSES
 
-    sessions[sid] = {
-        "status": "processing",
-        "frames": [],
-        "frames_lock": threading.Lock(),
-        "stats": {},
-        "summary": None,
-        "error": None,
-        "scene_name": scene_name,
-        "group_id": group_id,
-        "video_name": video_name,
-        "progress": 0,
-        "total_frames": 0,
-        "fps": 30.0,
-    }
+    with scene_lock:
+        scene_name = _next_scene_name(scene_name, group_id)
+        sessions[sid] = {
+            "status": "processing",
+            "frames": [],
+            "frames_lock": threading.Lock(),
+            "stats": {},
+            "summary": None,
+            "error": None,
+            "scene_name": scene_name,
+            "group_id": group_id,
+            "video_name": video_name,
+            "progress": 0,
+            "total_frames": 0,
+            "fps": 30.0,
+        }
 
     threading.Thread(
         target=_process_video_thread,
@@ -200,6 +243,114 @@ async def upload_video(
     return {"session_id": sid, "scene_name": scene_name, "group_id": group_id, "status": "processing"}
 
 
+@app.post("/webcam/start")
+async def start_webcam_detection(
+    scene_name: str = Form("webcam"),
+    group_id: str = Form("Group_05"),
+    classes: str = Form(""),
+    conf: float = Form(0.5),
+    model: str = Form("best.pt"),
+):
+    sid = str(uuid.uuid4())[:12]
+    with scene_lock:
+        scene_name = _next_scene_name(scene_name, group_id)
+        webcam_sessions[sid] = {
+            "status": "loading",
+            "tracker": None,
+            "tracker_lock": threading.Lock(),
+            "summary": None,
+            "error": None,
+            "scene_name": scene_name,
+            "group_id": group_id,
+        }
+
+    selected = [c.strip() for c in classes.split(",") if c.strip()] or DEFAULT_CLASSES
+
+    try:
+        webcam_sessions[sid]["tracker"] = TrafficTracker(
+            model_path=model,
+            selected_classes=selected,
+            conf_threshold=conf,
+            scene_name=scene_name,
+            group_id=group_id,
+            video_name="webcam",
+            output_dir=str(LOG_DIR),
+        )
+        webcam_sessions[sid]["status"] = "processing"
+    except Exception as exc:
+        webcam_sessions[sid]["status"] = "error"
+        webcam_sessions[sid]["error"] = str(exc)
+        raise HTTPException(500, f"Could not start webcam detection: {exc}") from exc
+
+    return {"session_id": sid, "scene_name": scene_name, "group_id": group_id, "status": "processing"}
+
+
+@app.post("/webcam/frame/{sid}")
+async def detect_webcam_frame(sid: str, file: UploadFile = File(...)):
+    session = webcam_sessions.get(sid)
+    if not session:
+        raise HTTPException(404, "Webcam session not found")
+    if session["status"] == "error":
+        raise HTTPException(500, session.get("error") or "Webcam session failed")
+    tracker = session.get("tracker")
+    if tracker is None:
+        raise HTTPException(202, "Webcam model is still loading")
+
+    raw = await file.read()
+    np_buf = np.frombuffer(raw, dtype=np.uint8)
+    frame = cv2.imdecode(np_buf, cv2.IMREAD_COLOR)
+    if frame is None:
+        raise HTTPException(400, "Could not decode webcam frame")
+
+    with session["tracker_lock"]:
+        if tracker.frame_width == 0 or tracker.frame_height == 0:
+            tracker.setup_frame_source(frame.shape[1], frame.shape[0], fps=5.0)
+
+        annotated, frame_stat = tracker.process_frame(frame)
+
+    _, buf = cv2.imencode(".jpg", annotated, [cv2.IMWRITE_JPEG_QUALITY, 80])
+    cumulative = frame_stat.get("cumulative") or {}
+    stats_payload = {
+        "frame":       frame_stat.get("frame", 0),
+        "timestamp":   round(frame_stat.get("timestamp", 0.0), 2),
+        "scene":       session["scene_name"],
+        "detections":  frame_stat.get("detections", 0),
+        "any_visible": frame_stat.get("any_visible", False),
+        "cumulative":  cumulative,
+        "total_unique": int(sum(cumulative.values())),
+    }
+
+    return {
+        "frame": base64.b64encode(buf).decode(),
+        "stats": stats_payload,
+    }
+
+
+@app.post("/webcam/stop/{sid}")
+async def stop_webcam_detection(sid: str):
+    session = webcam_sessions.get(sid)
+    if not session:
+        raise HTTPException(404, "Webcam session not found")
+    tracker = session.get("tracker")
+    if tracker is None:
+        webcam_sessions.pop(sid, None)
+        return {"status": "stopped"}
+
+    with session["tracker_lock"]:
+        log_paths = tracker.save_logs()
+        summary = tracker.get_summary()
+        summary["session_id"] = sid
+        summary["log_files"] = log_paths
+        summary["total_unique"] = int(sum(summary.get("count_per_class", {}).values()))
+        summary_path = Path(log_paths.get("summary", ""))
+        if summary_path.exists():
+            summary_path.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+
+    session["summary"] = summary
+    session["status"] = "done"
+    return {"status": "stopped", "summary": summary}
+
+
 def _process_video_thread(sid, video_path, scene_name, group_id, video_name, selected_classes, conf, model_name):
     """
     Processes video as fast as possible (no artificial sleep).
@@ -397,6 +548,10 @@ async def dashboard_data():
         s["summary"] for s in sessions.values()
         if s["status"] == "done" and s["summary"]
     ]
+    completed.extend(
+        s["summary"] for s in webcam_sessions.values()
+        if s["status"] == "done" and s["summary"]
+    )
     for p in sorted(LOG_DIR.glob("*_summary.json")):
         try:
             data = json.loads(p.read_text())

backend/tracker.py

@@ -11,6 +11,7 @@ import cv2
 import csv
 import json
 import math
+import re
 import uuid
 import numpy as np
 from pathlib import Path
@@ -106,24 +107,26 @@ class TrafficTracker:
         Cherche les fichiers existants avec le pattern Group_X_Y_NNN_*.
         """
         try:
-            pattern = f"{self.group_id}_{self.scene_name}_*"
+            prefix = f"{self.group_id}_{self.scene_name}"
+            pattern = f"{prefix}_*"
+            order_pattern = re.compile(rf"^{re.escape(prefix)}_(\d{{3}})(?:_|\.|$)")
             existing = list(self.output_dir.glob(pattern))
             if not existing:
                 return 1
-            # Extraire les numéros d'ordre des fichiers existants
             numbers = []
             for f in existing:
-                parts = f.name.split("_")
-                if len(parts) >= 3:
-                    try:
-                        num = int(parts[2])
-                        numbers.append(num)
-                    except ValueError:
-                        pass
+                match = order_pattern.match(f.name)
+                if match:
+                    numbers.append(int(match.group(1)))
             return max(numbers, default=0) + 1
         except Exception:
             return 1
 
+    def setup_frame_source(self, width: int, height: int, fps: float = 5.0):
+        self.fps = fps or 5.0
+        self.frame_width = width
+        self.frame_height = height
+
     # ── Setup ──────────────────────────────────────────────────────────────────
     def setup_video(self, cap: cv2.VideoCapture, save_output: bool = True):
         self.fps          = cap.get(cv2.CAP_PROP_FPS) or 30.0

frontend/index.html

@@ -510,6 +510,7 @@
         <div class="no-signal-sub">Upload a video and click START</div>
       </div>
       <canvas id="liveCanvas"></canvas>
+      <video id="webcamVideo" autoplay muted playsinline style="display:none"></video>
       <div id="bufferInfo">BUF: 0</div>
     </div>
 
@@ -558,6 +559,7 @@
     <div class="s-sect">
       <div class="s-label">Frame Info</div>
       <button class="btn btn-primary" id="startBtn" onclick="startProcessing()">▶ START ANALYSIS</button>
+      <button class="btn btn-secondary" id="webcamBtn" onclick="startWebcam()">▣ START WEBCAM</button>
       <button class="btn btn-secondary" id="stopBtn" style="display:none" onclick="stopProcessing()">■ STOP</button>
       <button class="btn btn-secondary" id="watchVideoBtn" style="display:none;text-align:center;margin-top:7px" onclick="openVideoPlayer()">▶ WATCH VIDEO</button>
       <div class="prog-bar"><div class="prog-fill" id="progFill"></div></div>
@@ -606,6 +608,10 @@ let sseSource   = null;
 let selectedFile = null;
 let pollTimer   = null;
 let dashboardCache = null;
+let webcamStream = null;
+let webcamSid = null;
+let webcamTimer = null;
+let webcamBusy = false;
 
 // Canvas
 const canvas = document.getElementById('liveCanvas');
@@ -700,10 +706,12 @@ function switchTab(tab, btn) {
 
 // ══ PROCESSING ════════════════════════════════════════════════════════════════
 async function startProcessing() {
+  if (webcamSid || webcamStream) await stopWebcam(false);
+
   const videoUrl = document.getElementById('videoUrl').value.trim();
   if (!selectedFile && !videoUrl) { toast('Upload a video file or enter a video URL.', 'err'); return; }
 
-  const selected = [...document.querySelectorAll('#classGrid input:checked')].map(i => i.value);
+  const selected = getSelectedClasses();
   if (!selected.length) { toast('Select at least one class.', 'err'); return; }
 
   const fd = new FormData();
@@ -739,6 +747,7 @@ async function startProcessing() {
           try {
             const data = JSON.parse(xhr.responseText);
             currentSid = data.session_id;
+            document.getElementById('sceneName').value = data.scene_name;
             localStorage.setItem('trafficTracker:lastSessionId', currentSid);
             toast(`Session: ${currentSid}`, 'ok');
             startSSE(currentSid);
@@ -775,7 +784,15 @@ async function startProcessing() {
   }
 }
 
-function stopProcessing() {
+function getSelectedClasses() {
+  return [...document.querySelectorAll('#classGrid input:checked')].map(i => i.value);
+}
+
+function stopProcessing(showToast = true) {
+  if (webcamSid || webcamStream) {
+    stopWebcam(showToast);
+    return;
+  }
   if (sseSource)   { sseSource.close(); sseSource = null; }
   if (pollTimer)   { clearInterval(pollTimer); pollTimer = null; }
   if (rafId)       { cancelAnimationFrame(rafId); rafId = null; }
@@ -784,18 +801,129 @@ function stopProcessing() {
   videoStart      = null;
   lastRenderedPts = -1;
   setUI('idle');
-  toast('Stopped.', '');
+  if (showToast) toast('Stopped.', '');
+}
+
+async function startWebcam() {
+  const selected = getSelectedClasses();
+  if (!selected.length) { toast('Select at least one class.', 'err'); return; }
+
+  stopProcessing(false);
+  resetCounters();
+  setUI('processing');
+  setConn('proc', 'WEBCAM');
+
+  try {
+    webcamStream = await navigator.mediaDevices.getUserMedia({
+      video: { facingMode: 'environment' },
+      audio: false,
+    });
+
+    const video = document.getElementById('webcamVideo');
+    video.srcObject = webcamStream;
+    await video.play();
+
+    const fd = new FormData();
+    fd.append('scene_name', document.getElementById('sceneName').value || 'webcam');
+    fd.append('group_id', document.getElementById('groupId').value || 'group_01');
+    fd.append('classes', selected.join(','));
+    fd.append('conf', document.getElementById('confVal').value);
+    fd.append('model', document.getElementById('modelSel').value);
+
+    const r = await fetch(`${API_BASE}/webcam/start`, { method: 'POST', body: fd });
+    if (!r.ok) throw new Error(await r.text());
+    const data = await r.json();
+    webcamSid = data.session_id;
+    currentSid = webcamSid;
+    document.getElementById('sceneName').value = data.scene_name;
+
+    document.getElementById('noSignal').style.display = 'none';
+    canvas.style.display = 'block';
+    document.getElementById('bufferInfo').style.display = 'block';
+    document.getElementById('bufferInfo').textContent = 'WEBCAM';
+    toast(`Webcam session: ${webcamSid}`, 'ok');
+
+    webcamTimer = setInterval(captureWebcamFrame, 220);
+  } catch (e) {
+    toast('Webcam failed: ' + e.message, 'err');
+    await stopWebcam(false);
+  }
+}
+
+async function captureWebcamFrame() {
+  if (!webcamSid || webcamBusy) return;
+  const video = document.getElementById('webcamVideo');
+  if (!video.videoWidth || !video.videoHeight) return;
+
+  webcamBusy = true;
+  try {
+    const capture = document.createElement('canvas');
+    capture.width = video.videoWidth;
+    capture.height = video.videoHeight;
+    capture.getContext('2d').drawImage(video, 0, 0, capture.width, capture.height);
+
+    const blob = await new Promise(resolve => capture.toBlob(resolve, 'image/jpeg', 0.75));
+    if (!blob) return;
+
+    const fd = new FormData();
+    fd.append('file', blob, 'webcam.jpg');
+    const r = await fetch(`${API_BASE}/webcam/frame/${encodeURIComponent(webcamSid)}`, {
+      method: 'POST',
+      body: fd,
+    });
+    if (!r.ok) return;
+
+    const data = await r.json();
+    const img = new Image();
+    img.onload = () => {
+      if (canvas.width !== img.naturalWidth) canvas.width = img.naturalWidth;
+      if (canvas.height !== img.naturalHeight) canvas.height = img.naturalHeight;
+      ctx.drawImage(img, 0, 0);
+    };
+    img.src = 'data:image/jpeg;base64,' + data.frame;
+    applyStats(data.stats);
+    document.getElementById('bufferInfo').textContent = 'WEBCAM LIVE';
+  } finally {
+    webcamBusy = false;
+  }
+}
+
+async function stopWebcam(showToast = true) {
+  if (webcamTimer) {
+    clearInterval(webcamTimer);
+    webcamTimer = null;
+  }
+  if (webcamStream) {
+    webcamStream.getTracks().forEach(track => track.stop());
+    webcamStream = null;
+  }
+  const sid = webcamSid;
+  webcamSid = null;
+  webcamBusy = false;
+
+  if (sid) {
+    try {
+      await fetch(`${API_BASE}/webcam/stop/${encodeURIComponent(sid)}`, { method: 'POST' });
+      loadDashboard();
+    } catch {}
+  }
+
+  setUI('idle');
+  if (showToast) toast('Webcam stopped.', '');
 }
 
 function setUI(state) {
   const start = document.getElementById('startBtn');
   const stop  = document.getElementById('stopBtn');
+  const webcam = document.getElementById('webcamBtn');
   if (state === 'processing') {
     start.disabled = true;
+    webcam.disabled = true;
     stop.style.display = 'block';
     setConn('proc', 'PROCESSING');
   } else {
     start.disabled = false;
+    webcam.disabled = false;
     stop.style.display = 'none';
     document.getElementById('progFill').style.width = '0%';
     document.getElementById('progLabel').textContent = '';