Analyse de trafic routier

Introduction

Pour l'analyse de trafic routier, comprenant le comptage des véhicules et la mesure de leur vitesse, il existe plusieurs approches et outils disponibles. Voici une solution détaillée basée sur des techniques de vision par ordinateur avec des frameworks tels qu'OpenCV et des modèles de deep learning pour la détection d'objets et le suivi.

Outils Utilisés

OpenCV

OpenCV (Open Source Computer Vision Library) est une bibliothèque de vision par ordinateur qui fournit une vaste gamme de fonctions pour le traitement d'images et la vision par ordinateur. Elle est utilisée pour :

• Lecture et écriture de vidéos et d'images : OpenCV peut lire des flux vidéo en temps réel à partir de caméras ou de fichiers vidéo.
• Traitement d'images : OpenCV offre des fonctions pour la conversion de couleurs, le redimensionnement, la détection de contours, etc.
• Affichage des résultats : OpenCV peut afficher des images et des vidéos avec des annotations (par exemple, boîtes englobantes et étiquettes).

YOLO

YOLO (You Only Look Once) est une famille de modèles de deep learning pour la détection d'objets en temps réel. Il est utilisé pour :

• Détection d'objets : YOLO détecte et localise les véhicules dans les images vidéo. Il produit des boîtes englobantes avec des scores de confiance et des classes d'objets.
• Vitesse et efficacité : YOLO est conçu pour être rapide, ce qui le rend approprié pour les applications en temps réel.

SORT

SORT (Simple Online and Realtime Tracking) est un algorithme de suivi d'objets qui est utilisé pour :

• Suivi des objets détectés : SORT prend les boîtes englobantes des véhicules détectés par YOLO et les suit d'une image à l'autre.
• Attribution d'ID unique : SORT attribue un ID unique à chaque véhicule, permettant de suivre chaque véhicule individuellement sur plusieurs images.

Combinaison des outils

Voici un exemple de flux de travail combinant OpenCV, YOLO et SORT pour une analyse de trafic routier :

1. Lecture du flux vidéo avec OpenCV.
2. Détection des véhicules dans chaque image avec YOLO.
3. Suivi des véhicules détectés d'une image à l'autre avec SORT.
4. Calcul de la vitesse des véhicules en utilisant les positions suivies et l'intervalle de temps entre les images.
5. Affichage des résultats avec OpenCV, incluant les boîtes englobantes, les IDs des véhicules et les vitesses.

Exemple de mise en œuvre

Installation des dépendances

<syntaxhighlight lang="bash"> pip install opencv-python numpy sort </syntaxhighlight>

Téléchargez les fichiers nécessaires pour YOLO

• YOLOv3 weights
• YOLOv3 configuration
• COCO names

Script Python pour l'analyse de trafic routier

<syntaxhighlight lang="python"> import cv2 import numpy as np from sort import Sort

1. Charger les classes COCO

with open("coco.names", "r") as f:

   classes = f.read().strip().split("\n")

1. Charger le modèle YOLO

net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")

1. Initialiser le tracker SORT

tracker = Sort()

1. Fonction pour convertir les boîtes englobantes YOLO en format (x, y, w, h)

def yolo_to_bbox(output, width, height):

   bboxes = []
   confidences = []
   class_ids = []

   for detection in output:
       scores = detection[5:]
       class_id = np.argmax(scores)
       confidence = scores[class_id]
       
       if confidence > 0.5 and classes[class_id] in ["car", "truck", "bus", "motorbike"]:  # Détecter les véhicules
           box = detection[:4] * np.array([width, height, width, height])
           (centerX, centerY, w, h) = box.astype("int")
           x = int(centerX - (w / 2))
           y = int(centerY - (h / 2))
           
           bboxes.append([x, y, w, h])
           confidences.append(float(confidence))
           class_ids.append(class_id)
   
   return bboxes, confidences, class_ids

1. Lecture de la vidéo

cap = cv2.VideoCapture("traffic_video.mp4") fps = cap.get(cv2.CAP_PROP_FPS)

while cap.isOpened():

   ret, frame = cap.read()
   if not ret:
       break
   
   height, width = frame.shape[:2]
   
   # Préparer l'image pour YOLO
   blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
   net.setInput(blob)
   
   layer_names = net.getLayerNames()
   output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
   
   outputs = net.forward(output_layers)
   bboxes = []
   confidences = []
   class_ids = []
   
   for output in outputs:
       bboxes_, confidences_, class_ids_ = yolo_to_bbox(output, width, height)
       bboxes.extend(bboxes_)
       confidences.extend(confidences_)
       class_ids.extend(class_ids_)
   
   # Appliquer la suppression des non-maxima
   indices = cv2.dnn.NMSBoxes(bboxes, confidences, 0.5, 0.4)
   detections = []
   if len(indices) > 0:
       for i in indices.flatten():
           x, y, w, h = bboxes[i]
           detections.append([x, y, x + w, y + h, confidences[i]])
   
   # Mettre à jour le tracker SORT
   tracked_objects = tracker.update(np.array(detections))
   
   for obj in tracked_objects:
       x1, y1, x2, y2, obj_id = obj
       cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
       cv2.putText(frame, f"ID: {int(obj_id)}", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
   
   # Afficher le résultat
   cv2.imshow("Traffic Analysis", frame)
   if cv2.waitKey(1) & 0xFF == ord('q'):
       break

cap.release() cv2.destroyAllWindows() </syntaxhighlight>

Calcul de la vitesse

Pour calculer la vitesse des véhicules, vous devez :

1. Convertir les pixels en unités réelles en utilisant les paramètres de calibration de la caméra.
2. Calculer la distance parcourue par chaque véhicule entre les images consécutives.
3. Calculer la vitesse en utilisant la distance parcourue et le temps écoulé entre les images.

Conclusion

OpenCV, YOLO et SORT forment un ensemble puissant pour la détection et le suivi des véhicules dans les applications de trafic routier. Cette combinaison permet de réaliser des analyses en temps réel, d'identifier et de suivre les véhicules, et de calculer leurs vitesses avec une précision raisonnable. En affinant ces techniques et en utilisant des algorithmes de calibration de la caméra, vous pouvez obtenir des mesures précises et fiables pour l'analyse du trafic routier.