VisionEye Visualizza la mappatura degli oggetti utilizzando Ultralytics YOLO11 🚀

Che cos'è la mappatura degli oggetti di VisionEye?

Ultralytics YOLO11 VisionEye consente ai computer di identificare e individuare gli oggetti, simulando la precisione di osservazione dell'occhio umano. Questa funzionalità consente ai computer di individuare e mettere a fuoco oggetti specifici, proprio come l'occhio umano osserva i dettagli da un particolare punto di vista.

Campioni

Vista VisionEye	Vista VisionEye con tracciamento degli oggetti	Vista VisionEye con calcolo della distanza

VisionEye Visualizza la mappatura degli oggetti utilizzando Ultralytics YOLO11	VisionEye Visualizza la mappatura degli oggetti con il tracciamento degli oggetti utilizzando Ultralytics YOLO11	Vista VisionEye con calcolo della distanza tramite Ultralytics YOLO11

Mappatura degli oggetti VisionEye con YOLO11

Mappatura degli oggetti VisionEyeMappatura degli oggetti VisionEye con tracciamento degli oggettiVisionEye con calcolo della distanza

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` Argomenti

Nome	Tipo	Predefinito	Descrizione
`color`	`tuple`	`(235, 219, 11)`	Colore del centroide della linea e dell'oggetto
`pin_color`	`tuple`	`(255, 0, 255)`	VisionEye colore pinpoint

Nota

Per qualsiasi richiesta, non esitate a postare le vostre domande nella sezione Problemi diUltralytics o nella sezione di discussione indicata di seguito.

FAQ

Come si inizia a utilizzare VisionEye Object Mapping con Ultralytics YOLO11 ?

Per iniziare a usare VisionEye Object Mapping con Ultralytics YOLO11 , è necessario installare il pacchetto Ultralytics YOLO tramite pip. Quindi, si può utilizzare il codice di esempio fornito nella documentazione per impostare il rilevamento degli oggetti con VisionEye. Ecco un semplice esempio per iniziare:

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()

Quali sono le caratteristiche principali della capacità di tracciamento degli oggetti di VisionEye utilizzando Ultralytics YOLO11 ?

Il tracciamento degli oggetti di VisionEye con Ultralytics YOLO11 consente agli utenti di seguire il movimento degli oggetti all'interno di un fotogramma video. Le caratteristiche principali includono:

Tracciamento degli oggetti in tempo reale: Segue gli oggetti mentre si muovono.
Identificazione degli oggetti: Utilizza i potenti algoritmi di rilevamento di YOLO11.
Calcolo della distanza: Calcola le distanze tra gli oggetti e i punti specificati.
Annotazione e visualizzazione: Fornisce marcatori visivi per gli oggetti tracciati.

Ecco un breve frammento di codice che dimostra il tracciamento con 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()

Per una guida completa, visitate il sito VisionEye Object Mapping with Object Tracking.

Come posso calcolare le distanze con il modello YOLO11 di VisionEye?

Il calcolo della distanza con VisionEye e Ultralytics YOLO11 comporta la determinazione della distanza degli oggetti rilevati da un punto specifico dell'inquadratura. Migliora le capacità di analisi spaziale, utili in applicazioni come la guida autonoma e la sorveglianza.

Ecco un esempio semplificato:

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()

Per istruzioni dettagliate, consultare VisionEye con calcolo della distanza.

Perché utilizzare Ultralytics YOLO11 per la mappatura e il tracciamento degli oggetti?

Ultralytics YOLO11 è rinomato per la sua velocità, precisione e facilità di integrazione, che lo rendono la scelta migliore per la mappatura e il tracciamento degli oggetti. I vantaggi principali includono:

Prestazioni all'avanguardia: Offre un'elevata precisione nel rilevamento degli oggetti in tempo reale.
Flessibilità: Supporta diverse attività come il rilevamento, il tracciamento e il calcolo della distanza.
Comunità e supporto: Ampia documentazione e comunità GitHub attiva per la risoluzione dei problemi e i miglioramenti.
Facilità d'uso: l'API intuitiva semplifica le attività complesse, consentendo una rapida implementazione e iterazione.

Per ulteriori informazioni sulle applicazioni e sui vantaggi, consultate la documentazione di Ultralytics YOLO11 .

Come posso integrare VisionEye con altri strumenti di apprendimento automatico come Comet o ClearML?

Ultralytics YOLO11 può integrarsi perfettamente con vari strumenti di apprendimento automatico come Comet e ClearML, migliorando il tracciamento degli esperimenti, la collaborazione e la riproducibilità. Seguite le guide dettagliate su come utilizzare YOLOv5 con Comet e integrare YOLO11 con ClearML per iniziare.

Per ulteriori approfondimenti ed esempi di integrazione, consultate la nostra Guida alle integrazioni diUltralytics .

📅C reato 11 mesi fa ✏️ Aggiornato 1 mese fa