VisionEye View Object Mapping using Ultralytics YOLO11 🚀

Qu'est-ce que la cartographie d'objets VisionEye ?

Ultralytics YOLO11 VisionEye permet aux ordinateurs d'identifier et de pointer des objets, en simulant la précision d' observation de l'œil humain. Cette fonctionnalité permet aux ordinateurs de discerner et de se concentrer sur des objets spécifiques, de la même manière que l'œil humain observe des détails à partir d'un point de vue particulier.

Échantillons

VisionEye View	VisionEye View avec suivi d'objet	VisionEye Vue avec calcul de la distance

VisionEye View Object Mapping utilisant Ultralytics YOLO11	VisionEye View Object Mapping with Object Tracking using Ultralytics YOLO11	VisionEye View avec calcul de la distance à l'aide de Ultralytics YOLO11

VisionEye Object Mapping (cartographie d'objets) YOLO11

Cartographie d'objets VisionEyeVisionEye Object Mapping avec Object TrackingVisionEye avec calcul de la distance

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolo11n.pt")
names = model.model.names
cap = cv2.VideoCapture("path/to/video/file.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("visioneye-pinpoint.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

center_point = (-10, h)

while True:
    ret, im0 = cap.read()
    if not ret:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    results = model.predict(im0)
    boxes = results[0].boxes.xyxy.cpu()
    clss = results[0].boxes.cls.cpu().tolist()

    annotator = Annotator(im0, line_width=2)

    for box, cls in zip(boxes, clss):
        annotator.box_label(box, label=names[int(cls)], color=colors(int(cls)))
        annotator.visioneye(box, center_point)

    out.write(im0)
    cv2.imshow("visioneye-pinpoint", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("visioneye-pinpoint.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

center_point = (-10, h)

while True:
    ret, im0 = cap.read()
    if not ret:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    annotator = Annotator(im0, line_width=2)

    results = model.track(im0, persist=True)
    boxes = results[0].boxes.xyxy.cpu()

    if results[0].boxes.id is not None:
        track_ids = results[0].boxes.id.int().cpu().tolist()

        for box, track_id in zip(boxes, track_ids):
            annotator.box_label(box, label=str(track_id), color=colors(int(track_id)))
            annotator.visioneye(box, center_point)

    out.write(im0)
    cv2.imshow("visioneye-pinpoint", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

import math

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator

model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

out = cv2.VideoWriter("visioneye-distance-calculation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

center_point = (0, h)
pixel_per_meter = 10

txt_color, txt_background, bbox_clr = ((0, 0, 0), (255, 255, 255), (255, 0, 255))

while True:
    ret, im0 = cap.read()
    if not ret:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    annotator = Annotator(im0, line_width=2)

    results = model.track(im0, persist=True)
    boxes = results[0].boxes.xyxy.cpu()

    if results[0].boxes.id is not None:
        track_ids = results[0].boxes.id.int().cpu().tolist()

        for box, track_id in zip(boxes, track_ids):
            annotator.box_label(box, label=str(track_id), color=bbox_clr)
            annotator.visioneye(box, center_point)

            x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2)  # Bounding box centroid

            distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2)) / pixel_per_meter

            text_size, _ = cv2.getTextSize(f"Distance: {distance:.2f} m", cv2.FONT_HERSHEY_SIMPLEX, 1.2, 3)
            cv2.rectangle(im0, (x1, y1 - text_size[1] - 10), (x1 + text_size[0] + 10, y1), txt_background, -1)
            cv2.putText(im0, f"Distance: {distance:.2f} m", (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 1.2, txt_color, 3)

    out.write(im0)
    cv2.imshow("visioneye-distance-calculation", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

`visioneye` Arguments

Nom	Type	Défaut	Description
`color`	`tuple`	`(235, 219, 11)`	Couleur des centroïdes des lignes et des objets
`pin_color`	`tuple`	`(255, 0, 255)`	VisionEye pinpoint color

Note

Pour toute question, n'hésitez pas à poster vos questions dans la section "Ultralytics Issue Section" ou dans la section de discussion mentionnée ci-dessous.

FAQ

Comment commencer à utiliser VisionEye Object Mapping avec Ultralytics YOLO11 ?

Pour commencer à utiliser VisionEye Object Mapping avec Ultralytics YOLO11 , vous devez d'abord installer le paquet Ultralytics YOLO via pip. Ensuite, vous pouvez utiliser le code d'exemple fourni dans la documentation pour configurer la détection d'objets avec VisionEye. Voici un exemple simple pour commencer :

import cv2

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model.predict(frame)
    for result in results:
        # Perform custom logic with result
        pass

    cv2.imshow("visioneye", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Quelles sont les principales caractéristiques de la capacité de suivi d'objets de VisionEye à l'aide de Ultralytics YOLO11 ?

Le suivi d'objets de VisionEye avec Ultralytics YOLO11 permet aux utilisateurs de suivre le mouvement d'objets dans une image vidéo. Les principales caractéristiques sont les suivantes :

Suivi des objets en temps réel: Suivi des objets au fur et à mesure qu'ils se déplacent.
Identification des objets: Utilise les puissants algorithmes de détection de YOLO11.
Calcul de la distance: Calcule les distances entre les objets et les points spécifiés.
Annotation et visualisation: Fournit des marqueurs visuels pour les objets suivis.

Voici un bref extrait de code démontrant le suivi avec VisionEye :

import cv2

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model.track(frame, persist=True)
    for result in results:
        # Annotate and visualize tracking
        pass

    cv2.imshow("visioneye-tracking", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Pour un guide complet, visitez le site VisionEye Object Mapping with Object Tracking.

Comment calculer les distances avec le modèle YOLO11 de VisionEye ?

Le calcul de la distance avec VisionEye et Ultralytics YOLO11 consiste à déterminer la distance des objets détectés par rapport à un point précis de l'image. Il améliore les capacités d'analyse spatiale, utiles dans des applications telles que la conduite autonome et la surveillance.

Voici un exemple simplifié :

import math

import cv2

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
center_point = (0, 480)  # Example center point
pixel_per_meter = 10

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model.track(frame, persist=True)
    for result in results:
        # Calculate distance logic
        distances = [
            (math.sqrt((box[0] - center_point[0]) ** 2 + (box[1] - center_point[1]) ** 2)) / pixel_per_meter
            for box in results
        ]

    cv2.imshow("visioneye-distance", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Pour obtenir des instructions détaillées, reportez-vous au document VisionEye avec calcul de la distance.

Pourquoi utiliser Ultralytics YOLO11 pour la cartographie et le suivi d'objets ?

Ultralytics YOLO11 est réputé pour sa rapidité, sa précision et sa facilité d'intégration, ce qui en fait un choix de premier ordre pour la cartographie et le suivi d'objets. Ses principaux avantages sont les suivants

Des performances de pointe: Détection d'objets en temps réel d'une grande précision.
Flexibilité: Prise en charge de diverses tâches telles que la détection, le suivi et le calcul de la distance.
Communauté et support: Documentation complète et communauté GitHub active pour le dépannage et les améliorations.
Facilité d'utilisation: l'API intuitive simplifie les tâches complexes, ce qui permet un déploiement et une itération rapides.

Pour plus d'informations sur les demandes et les avantages, consultez la documentationUltralytics YOLO11 .

Comment puis-je intégrer VisionEye avec d'autres outils d'apprentissage automatique comme Comet ou ClearML?

Ultralytics YOLO11 peut s'intégrer de manière transparente à divers outils d'apprentissage automatique tels que Comet et ClearML, améliorant ainsi le suivi des expériences, la collaboration et la reproductibilité. Suivez les guides détaillés sur l'utilisation de YOLOv5 avec Comet et l'intégration de YOLO11 avec ClearML pour commencer.

Pour une exploration plus approfondie et des exemples d'intégration, consultez notre guide des intégrationsUltralytics .

📅C réé il y a 11 mois ✏️ Mis à jour il y a 2 mois