update log

backend/main.py

@@ -67,6 +67,7 @@ async def get_classes():
 async def upload_video(
     file: UploadFile = File(...),
     scene_name: str = Form("scene_01"),
+    group_id: str = Form("group_01"),
     classes: str = Form(""),
     conf: float = Form(0.35),
     model: str = Form("yolov8n.pt"),
@@ -74,6 +75,7 @@ async def upload_video(
     sid = str(uuid.uuid4())[:12]
 
     suffix = Path(file.filename).suffix or ".mp4"
+    video_name = file.filename or f"{sid}{suffix}"
     video_path = UPLOAD_DIR / f"{sid}{suffix}"
     video_path.write_bytes(await file.read())
 
@@ -81,14 +83,14 @@ async def upload_video(
 
     sessions[sid] = {
         "status": "processing",
-        # Unlimited queue — frames are never dropped before the client reads them.
-        # We use a list + lock so the SSE generator can drain from the front.
-        "frames": [],          # list of {frame: b64, stats: {...}, pts: float}
+        "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,
@@ -96,14 +98,14 @@ async def upload_video(
 
     threading.Thread(
         target=_process_video_thread,
-        args=(sid, str(video_path), scene_name, selected, conf, model),
+        args=(sid, str(video_path), scene_name, group_id, video_name, selected, conf, model),
         daemon=True,
     ).start()
 
-    return {"session_id": sid, "scene_name": scene_name, "status": "processing"}
+    return {"session_id": sid, "scene_name": scene_name, "group_id": group_id, "status": "processing"}
 
 
-def _process_video_thread(sid, video_path, scene_name, selected_classes, conf, model_name):
+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).
     Each frame carries a `pts` (presentation timestamp in seconds) so the
@@ -125,6 +127,8 @@ def _process_video_thread(sid, video_path, scene_name, selected_classes, conf, m
             selected_classes=selected_classes,
             conf_threshold=conf,
             scene_name=scene_name,
+            group_id=group_id,
+            video_name=video_name,
             output_dir=str(LOG_DIR),
         )
         tracker.setup_video(cap)

backend/tracker.py

@@ -1,17 +1,16 @@
 """
 tracker.py — Core detection + tracking engine
-Uses YOLOv8 (ultralytics) with ByteTrack built-in tracker.
-
-Counting strategy: FIRST-SEEN — each unique track_id is counted exactly
-once, on the first frame it appears. No counting line.
-
-Video output: every processed frame (with bounding boxes) is written to
-an .mp4 file in the logs/ directory via cv2.VideoWriter.
+Counting : FIRST-SEEN (chaque track_id compté une seule fois dès sa 1re apparition)
+CSV log  : suit exactement le schéma SCHEMA_EXAMPLE.csv
+           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
 """
 
 import cv2
 import csv
 import json
+import math
 import uuid
 import numpy as np
 from pathlib import Path
@@ -19,7 +18,7 @@ from datetime import datetime
 from collections import defaultdict
 from ultralytics import YOLO
 
-# ─── Class configuration ──────────────────────────────────────────────────────
+# ─── Classes COCO traffic ─────────────────────────────────────────────────────
 TRAFFIC_CLASSES = {
     0: "person",
     1: "bicycle",
@@ -40,6 +39,15 @@ CLASS_COLORS = {
 
 DEFAULT_CLASSES = list(TRAFFIC_CLASSES.values())
 
+# Colonnes CSV — ordre exact du schéma
+CSV_COLUMNS = [
+    "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",
+]
+
 
 class TrafficTracker:
     def __init__(
@@ -48,18 +56,20 @@ class TrafficTracker:
         selected_classes: list = None,
         conf_threshold: float = 0.35,
         scene_name: str = "scene_01",
+        group_id: str = "group_01",
+        video_name: str = "video.mp4",
         output_dir: str = "logs",
     ):
-        # ── Model ─────────────────────────────────────────────────────────────
-        # model_path is selected in the frontend dropdown (main.py receives it
-        # as a form field and passes it here).
-        # To use a fine-tuned model, pass the path to your best.pt here, e.g.:
+        # ── Modèle ────────────────────────────────────────────────────────────
+        # Pour utiliser un modèle fine-tuné :
         #   model_path = "runs/detect/traffic_finetune/weights/best.pt"
         self.model            = YOLO(model_path)
 
         self.selected_classes = selected_classes or DEFAULT_CLASSES
         self.conf             = conf_threshold
         self.scene_name       = scene_name
+        self.group_id         = group_id          # <— nouveau champ schéma
+        self.video_name       = video_name        # <— nouveau champ schéma
         self.output_dir       = Path(output_dir)
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
@@ -71,19 +81,19 @@ class TrafficTracker:
         self.frame_height = 0
 
         # Tracking
-        self.track_history:   dict = defaultdict(list)
+        self.track_history:   dict = defaultdict(list)   # id -> [(cx,cy), ...]
         self.counted_ids:     set  = set()
         self.count_per_class: dict = defaultdict(int)
 
         # Logs
-        self.detection_log: list = []
-        self.frame_stats:   list = []
+        self.detection_log: list = []   # chaque ligne = une détection
+        self.frame_stats:   list = []   # résumé par frame
 
-        # Video writer (set in setup_video)
-        self.video_writer        = None
-        self.output_video_path   = None
+        # Video writer
+        self.video_writer      = None
+        self.output_video_path = None
 
-        # COCO class-id filter
+        # Filtre classes COCO
         self._class_ids = [
             cid for cid, name in TRAFFIC_CLASSES.items()
             if name in self.selected_classes
@@ -108,7 +118,7 @@ class TrafficTracker:
     # ── Process one frame ──────────────────────────────────────────────────────
     def process_frame(self, frame: np.ndarray) -> tuple:
         self.frame_index += 1
-        timestamp = self.frame_index / self.fps
+        timestamp_sec = round(self.frame_index / self.fps, 3)
 
         results = self.model.track(
             frame,
@@ -141,30 +151,60 @@ class TrafficTracker:
                 any_object_visible = True
                 per_class_in_frame[cls_name] += 1
 
-                # First-seen counting
+                # ── Vitesse (px/s) ────────────────────────────────────────────
+                # Distance euclidienne entre position courante et précédente,
+                # multipliée par fps pour obtenir des px/s.
+                speed_px_s = 0.0
+                if track_id != -1 and self.track_history[track_id]:
+                    prev_cx, prev_cy = self.track_history[track_id][-1]
+                    dist = math.hypot(cx - prev_cx, cy - prev_cy)
+                    speed_px_s = round(dist * self.fps, 1)
+
+                # ── Comptage first-seen ───────────────────────────────────────
                 is_new = False
                 if track_id != -1 and track_id not in self.counted_ids:
                     self.counted_ids.add(track_id)
                     self.count_per_class[cls_name] += 1
                     is_new = True
 
+                # Mise à jour historique
                 if track_id != -1:
                     self.track_history[track_id].append((cx, cy))
 
-                frame_detections.append({
-                    "frame":      self.frame_index,
-                    "timestamp":  round(timestamp, 3),
-                    "scene":      self.scene_name,
-                    "track_id":   track_id,
-                    "class":      cls_name,
-                    "confidence": round(conf_val, 3),
-                    "bbox":       [x1, y1, x2, y2],
-                    "center":     [cx, cy],
-                    "is_new":     is_new,
-                })
-                self.detection_log.append(frame_detections[-1])
-
-                # Draw bounding box
+                # ── Colonnes schéma : crossed_line & direction ─────────────────
+                # On ne dessine plus de ligne physique sur la vidéo, mais on
+                # conserve les colonnes dans le CSV (vide / false par défaut).
+                # Si tu veux réactiver le croisement de ligne, tu peux définir
+                # une ligne ici et compléter la logique.
+                crossed_line = False
+                direction    = ""
+
+                # ── Ligne CSV (schéma exact) ───────────────────────────────────
+                row = {
+                    "frame":        self.frame_index,
+                    "timestamp_sec": timestamp_sec,
+                    "scene_name":   self.scene_name,
+                    "group_id":     self.group_id,
+                    "video_name":   self.video_name,
+                    "track_id":     track_id,
+                    "class_name":   cls_name,
+                    "confidence":   round(conf_val, 3),
+                    "bbox_x1":      x1,
+                    "bbox_y1":      y1,
+                    "bbox_x2":      x2,
+                    "bbox_y2":      y2,
+                    "cx":           cx,
+                    "cy":           cy,
+                    "frame_width":  self.frame_width,
+                    "frame_height": self.frame_height,
+                    "crossed_line": str(crossed_line).lower(),   # "true"/"false"
+                    "direction":    direction,
+                    "speed_px_s":   speed_px_s,
+                }
+                frame_detections.append(row)
+                self.detection_log.append(row)
+
+                # ── Bounding box ───────────────────────────────────────────────
                 color     = CLASS_COLORS.get(cls_name, (255, 255, 255))
                 thickness = 3 if is_new else 2
                 cv2.rectangle(annotated, (x1, y1), (x2, y2), color, thickness)
@@ -186,13 +226,12 @@ class TrafficTracker:
 
         self._draw_counters(annotated, any_object_visible)
 
-        # Write annotated frame to output video
         if self.video_writer is not None:
             self.video_writer.write(annotated)
 
         frame_stat = {
             "frame":       self.frame_index,
-            "timestamp":   round(timestamp, 3),
+            "timestamp":   timestamp_sec,
             "scene":       self.scene_name,
             "detections":  len(frame_detections),
             "per_class":   dict(per_class_in_frame),
@@ -203,7 +242,7 @@ class TrafficTracker:
 
         return annotated, frame_stat
 
-    # ── Counters overlay ───────────────────────────────────────────────────────
+    # ── Overlay compteurs ──────────────────────────────────────────────────────
     def _draw_counters(self, frame: np.ndarray, any_visible: bool):
         overlay = frame.copy()
         cv2.rectangle(overlay, (0, 0),
@@ -225,9 +264,8 @@ class TrafficTracker:
             cv2.putText(frame, "NO OBJECTS DETECTED", (10, y + 10),
                         cv2.FONT_HERSHEY_SIMPLEX, 0.5, (80, 80, 80), 1)
 
-    # ── Finalise and save all logs ─────────────────────────────────────────────
+    # ── Sauvegarde des logs ────────────────────────────────────────────────────
     def save_logs(self) -> dict:
-        # Release video writer so the .mp4 is properly closed/flushed
         if self.video_writer is not None:
             self.video_writer.release()
             self.video_writer = None
@@ -235,28 +273,41 @@ class TrafficTracker:
         ts     = datetime.now().strftime("%Y%m%d_%H%M%S")
         prefix = f"{self.scene_name}_{ts}"
 
-        log_path = self.output_dir / f"{prefix}_detections.jsonl"
-        with open(log_path, "w") as f:
-            for entry in self.detection_log:
-                f.write(json.dumps(entry) + "\n")
-
+        # ── CSV principal — schéma exact ──────────────────────────────────────
+        csv_path = self.output_dir / f"{prefix}_detections.csv"
+        with open(csv_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=CSV_COLUMNS)
+            writer.writeheader()
+            for row in self.detection_log:
+                # S'assurer que toutes les colonnes sont présentes
+                writer.writerow({col: row.get(col, "") for col in CSV_COLUMNS})
+
+        # ── JSONL brut (optionnel, pour debug) ────────────────────────────────
+        jsonl_path = self.output_dir / f"{prefix}_detections.jsonl"
+        with open(jsonl_path, "w", encoding="utf-8") as f:
+            for row in self.detection_log:
+                f.write(json.dumps(row) + "\n")
+
+        # ── Summary JSON ──────────────────────────────────────────────────────
         summary  = self.get_summary()
         sum_path = self.output_dir / f"{prefix}_summary.json"
-        with open(sum_path, "w") as f:
+        with open(sum_path, "w", encoding="utf-8") as f:
             json.dump(summary, f, indent=2)
 
-        csv_path = self.output_dir / f"{prefix}_frame_stats.csv"
+        # ── Frame stats CSV (résumé par frame) ────────────────────────────────
+        fstats_path = self.output_dir / f"{prefix}_frame_stats.csv"
         if self.frame_stats:
-            with open(csv_path, "w", newline="") as f:
+            with open(fstats_path, "w", newline="", encoding="utf-8") as f:
                 writer = csv.DictWriter(f, fieldnames=self.frame_stats[0].keys())
                 writer.writeheader()
                 writer.writerows(self.frame_stats)
 
         return {
-            "detection_log":      str(log_path),
-            "summary":            str(sum_path),
-            "frame_stats":        str(csv_path),
-            "annotated_video":    self.output_video_path or "",
+            "detections_csv":   str(csv_path),
+            "detections_jsonl": str(jsonl_path),
+            "summary":          str(sum_path),
+            "frame_stats":      str(fstats_path),
+            "annotated_video":  self.output_video_path or "",
         }
 
     # ── Summary ─────────────────────────────────────────────────────────────────
@@ -272,6 +323,8 @@ class TrafficTracker:
 
         return {
             "scene":                 self.scene_name,
+            "group_id":              self.group_id,
+            "video_name":            self.video_name,
             "session_id":            self.session_id,
             "processed_at":          datetime.now().isoformat(),
             "total_frames":          self.frame_index,

frontend/index.html

@@ -321,6 +321,10 @@
         <label>SCENE NAME</label>
         <input type="text" id="sceneName" value="scene_01"/>
       </div>
+      <div class="field">
+        <label>GROUP ID</label>
+        <input type="text" id="groupId" value="group_01"/>
+      </div>
       <div class="field">
         <label>MODEL</label>
         <select id="modelSel">
@@ -538,6 +542,7 @@ async function startProcessing() {
   const fd = new FormData();
   fd.append('file',       selectedFile);
   fd.append('scene_name', document.getElementById('sceneName').value || 'scene_01');
+  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);