Suivi des objets Opencv : 3 étapes

2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-23 14:45

La détection d'objets en mouvement est une technique utilisée en vision par ordinateur et en traitement d'images. Plusieurs images consécutives d'une vidéo sont comparées par diverses méthodes pour déterminer si un objet en mouvement est détecté.

La détection d'objets en mouvement a été utilisée pour un large éventail d'applications telles que la vidéosurveillance, la reconnaissance d'activité, la surveillance de l'état des routes, la sécurité des aéroports, la surveillance de la protection le long des frontières maritimes, etc.

La détection d'objets en mouvement consiste à reconnaître le mouvement physique d'un objet dans un lieu ou une région donné.[2] En agissant sur la segmentation parmi les objets en mouvement et la zone ou la région stationnaire, le mouvement des objets en mouvement pourrait être suivi et ainsi analysé plus tard. Pour ce faire, considérez qu'une vidéo est une structure construite sur des images uniques, la détection d'objet en mouvement consiste à trouver la ou les cibles en mouvement au premier plan, soit dans chaque image vidéo, soit uniquement lorsque la cible en mouvement montre la première apparition dans la vidéo.

Je vais utiliser la combinaison Opnecv et Python pour détecter et suivre les objets en fonction de la couleur

Étape 1: dessin d'un rectangle sur l'objet reconnu

si votre pc n'a pas python ou opencv, veuillez suivre les instructions ci-dessous

voici le code python:

importer cv2import numpy en tant que np

cap = cv2. Capture Vidéo(0)

tant que vrai:

_, cadre = cap.read() hsv = cv2.cvtColor(cadre, cv2. COLOR_BGR2HSV)

inférieur_jaune = np.array([20, 110, 110])

upper_yellow = np.array([40, 255, 255])

yellow_mask = cv2.inRange(hsv, lower_yellow, upper_yellow)

(_, contours, _) = cv2.findContours(yellow_mask, cv2. RETR_TREE, cv2. CHAIN_APPROX_SIMPLE)

pour contour dans contours:

zone = cv2.contourArea(contour)

si (zone > 800):

x, y, w, h = cv2.boundingRect(contour) frame = cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 10)

cv2.imshow("suivi", cadre)

k = cv2.waitKey(5) & 0XFF

si k == 27: cassure

cv2.destroyAllWindows()

cap.release()

Étape 2: Tracez le chemin dans lequel l'objet s'est déplacé

pour tracer le chemin:

for i in range(1, len(center_points)): b = random.randint(230, 255) g = random.randint(100, 255) r = random.randint(100, 255) if math.sqrt(((center_points[i - 1][0] - center_points[0]) ** 2) + ((center_points[i - 1][1] - center_points[1]) ** 2)) <= 50: cv2.line(frame, center_points[i - 1], center_points, (b, g, r), 4)

Étape 3: Intégration des deux codes

je vais intégrer les deux le code

import cv2import numpy as np import random from collections import deque

cap = cv2. CaptureVidéo(1)

# Pour garder une trace de tous les points où l'objet a visité center_points = deque()

tant que vrai:

# Lire et retourner le cadre _, cadre = cap.read() frame = cv2.flip(frame, 1)

# Flou un peu le cadre

blur_frame = cv2. GaussianBlur(frame, (7, 7), 0)

# Convertir du format couleur BGR au format HSV

hsv = cv2.cvtColor(flou_cadre, cv2. COLOR_BGR2HSV)

# Définir la plage inférieure et supérieure de la couleur hsv à détecter. Bleu ici

lower_blue = np.array([100, 50, 50]) upper_blue = np.array([140, 255, 255]) mask = cv2.inRange(hsv, lower_blue, upper_blue)

# Faire un noyau elliptique

noyau = cv2.getStructuringElement(cv2. MORPH_ELLIPSE, (15, 15))

# Ouverture morph (érosion suivie d'une dilatation)

masque = cv2.morphologyEx(masque, cv2. MORPH_OPEN, noyau)

# Trouver tous les contours

contours, hiérarchie = cv2.findContours(mask.copy(), cv2. RETR_LIST, cv2. CHAIN_APPROX_SIMPLE)[-2:]

si longueur(contours) > 0:

# Trouver le plus grand contour plus grand_contour = max(contours, key=cv2.contourArea)

# Trouver le centre du contour et dessiner un cercle rempli

moments = cv2.moments(biggest_contour) centre_of_contour = (int(moments['m10'] / moments['m00']), int(moments['m01'] / moments['m00'])) cv2.circle(frame, centre_de_contour, 5, (0, 0, 255), -1)

# Limiter le contour avec un cercle

ellipse = cv2.fitEllipse(plus grand_contour) cv2.ellipse(cadre, ellipse, (0, 255, 255), 2)

# Enregistrez le centre du contour pour tracer une ligne en le suivant

center_points.appendleft(centre_of_contour)

# Tracez une ligne à partir des points centraux du contour

for i in range(1, len(center_points)): b = random.randint(230, 255) g = random.randint(100, 255) r = random.randint(100, 255) if math.sqrt(((center_points[i - 1][0] - center_points[0]) ** 2) + ((center_points[i - 1][1] - center_points[1]) ** 2)) <= 50: cv2.line(frame, center_points[i - 1], center_points, (b, g, r), 4)

cv2.imshow('original', cadre)

cv2.imshow('masque', masque)

k = cv2.waitKey(5) & 0xFF

si k == 27: cassure

cv2.destroyAllWindows()

cap.release()