Une brève introduction à l'algorithme de suivi SORT et à son exemple d'implémentation Python

SORT (Simple Online and Realtime Tracking) est un algorithme de suivi de cible basé sur le filtre de Kalman, qui peut suivre de manière robuste des cibles en mouvement dans des scènes en temps réel. L'algorithme SORT a été initialement proposé par Alex Bewley et d'autres en 2016. Il a été largement utilisé dans diverses applications dans le domaine de la vision par ordinateur, telles que la vidéosurveillance, la conduite autonome, la navigation des robots, etc.

L'algorithme SORT est principalement basé sur deux idées principales : le filtrage de Kalman et l'algorithme hongrois. Le filtre de Kalman est un algorithme d'estimation de l'état du système. Il peut utiliser le modèle dynamique du système et les mesures des capteurs pour prédire et mettre à jour l'état du système, améliorant ainsi la précision de l'estimation de l'état. L'algorithme hongrois est un algorithme utilisé pour résoudre le problème de correspondance de poids maximum des graphes bipartis. Il peut trouver la correspondance de poids maximum étant donné un graphe biparti.

Les principales étapes de l'algorithme SORT sont les suivantes :

Détection de cible : utilisez des algorithmes de détection de cible (tels que YOLO, SSD, etc.) pour extraire les informations sur la cible dans la trame actuelle.

Prédiction d'état : pour chaque cible suivie, utilisez le filtre de Kalman pour prédire son état.

Association de données : en fonction de l'état de prédiction et des informations sur la cible dans la trame actuelle, utilisez l'algorithme hongrois pour effectuer une association de données afin de trouver la cible correspondant à chaque cible suivie dans la trame actuelle.

Mise à jour du statut : pour chaque cible suivie, utilisez le filtre Kalman pour mettre à jour son statut.

Sortie cible : affiche les informations d'état et les résultats de suivi de chaque cible suivie.

En vision par ordinateur, l'algorithme SORT peut être appliqué à divers scénarios de suivi de cible. Par exemple, en vidéosurveillance, l’algorithme SORT peut suivre des cibles en mouvement en temps réel, permettant ainsi la détection et l’alerte précoce des comportements anormaux sur la scène. Dans le domaine de la conduite autonome, l'algorithme SORT peut suivre d'autres véhicules, piétons et autres usagers de la route pour parvenir à une navigation autonome et éviter les obstacles des véhicules. Dans la navigation du robot, l'algorithme SORT peut suivre des cibles en mouvement pour parvenir à une navigation autonome et éviter les obstacles du robot.

Ce qui suit est un exemple de code simple implémenté en Python :

#python
import numpy as np
from filterpy.kalman import KalmanFilter
from scipy.optimize import linear_sum_assignment

class Track:

def init(self,prediction,track_id,track_lifetime):
    self.prediction=np.atleast_2d(prediction)
    self.track_id=track_id
    self.track_lifetime=track_lifetime
    self.age=0
    self.total_visible_count=1
    self.consecutive_invisible_count=0

def predict(self, kf):
    self.prediction = kf.predict()
    self.age += 1

def update(self, detection, kf):
    self.prediction = kf.update(detection)
    self.total_visible_count += 1
    self.consecutive_invisible_count = 0

def mark_missed(self):
    self.consecutive_invisible_count += 1

def is_dead(self):
    return self.consecutive_invisible_count >= self.track_lifetime

class Tracker:

def init(self,track_lifetime,detection_variance,process_variance):
    self.next_track_id=0
    self.tracks=[]
    self.track_lifetime=track_lifetime
    self.detection_variance=detection_variance
    self.process_variance=process_variance
    self.kf=KalmanFilter(dim_x=4,dim_z=2)
    self.kf.F=np.array([[1,0,1,0],
                    [0,1,0,1],
                    [0,0,1,0],
                    [0,0,0,1]])
    self.kf.H=np.array([[1,0,0,0],
                    [0,1,0,0]])
    self.kf.R=np.array([[self.detection_variance,0],
                    [0,self.detection_variance]])
    self.kf.Q=np.array([[self.process_variance,0,0,0],
                    [0,self.process_variance,0,0],
                    [0,0,self.process_variance,0],
                    [0,0,0,self.process_variance]])

def update(self, detections):
    # predict track positions using Kalman filter
    for track in self.tracks:
        track.predict(self.kf)

    # associate detections with tracks using Hungarian algorithm
    if len(detections) > 0:
        num_tracks = len(self.tracks)
        num_detections = len(detections)
        cost_matrix = np.zeros((num_tracks, num_detections))
        for i, track in enumerate(self.tracks):
            for j, detection in enumerate(detections):
                diff = track.prediction - detection
                distance = np.sqrt(diff[0,0]**2 + diff[0,1]**2)
                cost_matrix[i,j] = distance
        row_indices, col_indices = linear_sum_assignment(cost_matrix)
        unassigned_tracks = set(range(num_tracks)) - set(row_indices)
        unassigned_detections = set(range(num_detections)) - set(col_indices)
        for i, j in zip(row_indices, col_indices):
            self.tracks[i].update(detections[j], self.kf)
        for i in unassigned_tracks:
            self.tracks[i].mark_missed()
        for j in unassigned_detections:
            new_track = Track(detections[j], self.next_track_id, self.track_lifetime)
            self.tracks.append(new_track)
            self.next_track_id += 1

    # remove dead tracks
    self.tracks = [track for track in self.tracks if not track.is_dead()]

    # return list of track positions
    return [track.prediction.tolist()[0] for track in self.tracks]

Le code ci-dessus implémente un algorithme de suivi SORT simple, utilisant le filtre de Kalman pour prédire et estimer la position et la vitesse de la cible, puis utilisant l'algorithme hongrois pour effectuer suivi sur la cible. Association, et enfin déterminer si la cible est morte en fonction du nombre de fois invisibles consécutives de la cible et supprimer la cible morte. Le code ci-dessus implémente un algorithme de suivi SORT simple, utilisant le filtre de Kalman pour prédire et estimer la position et la vitesse de la cible, puis utilisant l'algorithme hongrois pour associer la cible, et enfin juger si la cible est morte et supprimer la mort en fonction du nombre. de temps invisibles consécutifs de la cible.

En plus de l'algorithme SORT, il existe de nombreux autres algorithmes de suivi de cible, tels que le filtre de Kalman, le filtre à particules, le suivi multi-cibles, etc. Chaque algorithme a ses scénarios applicables, ses avantages et ses inconvénients. Dans les applications pratiques, il est nécessaire de sélectionner un algorithme approprié pour le suivi de cible en fonction de scénarios et de besoins spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!