Analyse de trafic routier
Introduction[modifier]
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[modifier]
OpenCV[modifier]
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[modifier]
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[modifier]
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[modifier]
Voici un exemple de flux de travail combinant OpenCV, YOLO et SORT pour une analyse de trafic routier :
- Lecture du flux vidéo avec OpenCV.
- Détection des véhicules dans chaque image avec YOLO.
- Suivi des véhicules détectés d'une image à l'autre avec SORT.
- Calcul de la vitesse des véhicules en utilisant les positions suivies et l'intervalle de temps entre les images.
- Affichage des résultats avec OpenCV, incluant les boîtes englobantes, les IDs des véhicules et les vitesses.
Exemple de mise en œuvre[modifier]
Installation des dépendances[modifier]
<syntaxhighlight lang="bash"> pip install opencv-python numpy sort </syntaxhighlight>
Téléchargez les fichiers nécessaires pour YOLO[modifier]
Script Python pour l'analyse de trafic routier[modifier]
<syntaxhighlight lang="python"> import cv2 import numpy as np from sort import Sort
- Charger les classes COCO
with open("coco.names", "r") as f:
classes = f.read().strip().split("\n")
- Charger le modèle YOLO
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
- Initialiser le tracker SORT
tracker = Sort()
- 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
- 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[modifier]
Pour calculer la vitesse des véhicules, vous devez :
- Convertir les pixels en unités réelles en utilisant les paramètres de calibration de la caméra.
- Calculer la distance parcourue par chaque véhicule entre les images consécutives.
- Calculer la vitesse en utilisant la distance parcourue et le temps écoulé entre les images.
Conclusion[modifier]
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.