VisionEye View Object Mapping mit Ultralytics YOLOv8 🚀

Was ist VisionEye Object Mapping?

Ultralytics YOLOv8 VisionEye bietet Computern die Möglichkeit, Objekte zu identifizieren und zu fokussieren, indem es die Beobachtungsgenauigkeit des menschlichen Auges simuliert. Diese Funktion ermöglicht es Computern, bestimmte Objekte zu erkennen und zu fokussieren, ähnlich wie das menschliche Auge Details von einem bestimmten Blickwinkel aus wahrnimmt.

Proben

VisionEye Ansicht	VisionEye-Ansicht mit Objektverfolgung	VisionEye Ansicht mit Entfernungsberechnung

VisionEye View Object Mapping mit Ultralytics YOLOv8	VisionEye View Object Mapping mit Objektverfolgung mit Ultralytics YOLOv8	VisionEye-Ansicht mit Entfernungsberechnung mit Ultralytics YOLOv8

VisionEye Object Mapping mit YOLOv8

VisionEye Object MappingVisionEye Object Mapping mit ObjektverfolgungVisionEye mit Entfernungsberechnung

import cv2

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

model = YOLO("yolov8n.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("yolov8n.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("yolov8s.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` Argumente

Name	Typ	Standard	Beschreibung
`color`	`tuple`	`(235, 219, 11)`	Farbe des Linien- und Objektschwerpunkts
`pin_color`	`tuple`	`(255, 0, 255)`	VisionEye Pinpoint Farbe

Hinweis

Wenn du Fragen hast, kannst du sie im BereichUltralytics oder im unten stehenden Diskussionsbereich stellen.

FAQ

Wie verwende ich VisionEye Object Mapping mit Ultralytics YOLOv8 ?

Um VisionEye Object Mapping mit Ultralytics YOLOv8 nutzen zu können, musst du zunächst das Paket Ultralytics YOLO über pip installieren. Dann kannst du den in der Dokumentation enthaltenen Beispielcode verwenden, um die Objekterkennung mit VisionEye einzurichten. Hier ist ein einfaches Beispiel, das dir den Einstieg erleichtert:

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.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()

Was sind die Hauptmerkmale der Objektverfolgung von VisionEye mit Ultralytics YOLOv8 ?

Die Objektverfolgung von VisionEye mit Ultralytics YOLOv8 ermöglicht es, die Bewegung von Objekten in einem Videobild zu verfolgen. Die wichtigsten Funktionen sind:

Objektverfolgung in Echtzeit: Verfolgt die Objekte, während sie sich bewegen.
Objektidentifizierung: Nutzt die leistungsstarken Erkennungsalgorithmen von YOLOv8.
Entfernungsberechnung: Berechnet Entfernungen zwischen Objekten und bestimmten Punkten.
Beschriftung und Visualisierung: Bietet visuelle Markierungen für verfolgte Objekte.

Hier ist ein kurzer Codeschnipsel, der das Tracking mit VisionEye demonstriert:

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.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()

Einen umfassenden Leitfaden findest du im VisionEye Object Mapping mit Object Tracking.

Wie kann ich Entfernungen mit dem Modell von VisionEye YOLOv8 berechnen?

Bei der Entfernungsberechnung mit VisionEye und Ultralytics YOLOv8 wird die Entfernung der erkannten Objekte von einem bestimmten Punkt im Bild bestimmt. Sie verbessert die räumlichen Analysefähigkeiten, die in Anwendungen wie dem autonomen Fahren und der Überwachung nützlich sind.

Hier ist ein vereinfachtes Beispiel:

import math

import cv2

from ultralytics import YOLO

model = YOLO("yolov8s.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()

Ausführliche Anweisungen findest du im VisionEye mit Entfernungsberechnung.

Warum sollte ich Ultralytics YOLOv8 für Objektzuordnung und -verfolgung verwenden?

Ultralytics YOLOv8 ist bekannt für seine Schnelligkeit, Genauigkeit und einfache Integration, was es zur ersten Wahl für Objektkartierung und -verfolgung macht. Die wichtigsten Vorteile sind:

Modernste Leistung: Bietet eine hohe Genauigkeit bei der Objekterkennung in Echtzeit.
Flexibilität: Unterstützt verschiedene Aufgaben wie Erkennung, Verfolgung und Entfernungsberechnung.
Community und Support: Umfassende Dokumentation und aktive GitHub-Community für Fehlerbehebung und Verbesserungen.
Benutzerfreundlichkeit: Die intuitive API vereinfacht komplexe Aufgaben und ermöglicht eine schnelle Einführung und Wiederholung.

Weitere Informationen zu Anwendungen und Vorteilen findest du in der DokumentationUltralytics YOLOv8 .

Wie kann ich VisionEye mit anderen Machine-Learning-Tools wie Comet oder ClearML integrieren?

Ultralytics YOLOv8 lässt sich nahtlos in verschiedene Tools für maschinelles Lernen wie Comet und ClearML integrieren und verbessert die Nachverfolgung von Experimenten, die Zusammenarbeit und die Reproduzierbarkeit. Folge den detaillierten Anleitungen zur Nutzung von YOLOv5 mit Comet und zur Integration von YOLOv8 mit ClearML, um loszulegen.

Weitere Informationen und Integrationsbeispiele findest du in unserem Ultralytics Integrationsleitfaden.

Erstellt 2023-12-18, Aktualisiert 2024-07-05
Autoren: glenn-jocher (13), IvorZhu331 (1), RizwanMunawar (1)