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
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.
