VisionEye View Object Mapping mit Ultralytics YOLO11 🚀
Was ist VisionEye Object Mapping?
Ultralytics YOLO11 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 der Art und Weise, wie das menschliche Auge Details von einem bestimmten Standpunkt aus wahrnimmt.
Proben
| VisionEye-Ansicht | VisionEye-Ansicht mit Objektverfolgung | VisionEye-Ansicht mit Entfernungsberechnung |
|---|---|---|
 |
 |
 |
| VisionEye View Object Mapping mit Ultralytics YOLO11 | VisionEye View Object Mapping mit Objektverfolgung mit Ultralytics YOLO11 | VisionEye-Ansicht mit Entfernungsberechnung mit Ultralytics YOLO11 |
VisionEye Object Mapping mit YOLO11
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 Argumente
| Name | Typ | Standard | Beschreibung |
|---|---|---|---|
color |
tuple |
(235, 219, 11) |
Linien- und Objektschwerpunktfarbe |
pin_color |
tuple |
(255, 0, 255) |
VisionEye punktgenaue Farbe |
Hinweis
Wenn Sie Fragen haben, können Sie diese gerne im BereichUltralytics oder im unten genannten Diskussionsbereich stellen.
FAQ
Wie verwende ich VisionEye Object Mapping mit Ultralytics YOLO11 ?
Um VisionEye Object Mapping mit Ultralytics YOLO11 zu verwenden, müssen Sie zunächst das Paket Ultralytics YOLO über pip installieren. Anschließend können Sie den in der Dokumentation enthaltenen Beispielcode verwenden, um die Objekterkennung mit VisionEye einzurichten. Hier ist ein einfaches Beispiel für den Anfang:
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()
Was sind die Hauptmerkmale der Objektverfolgung von VisionEye mit Ultralytics YOLO11 ?
Die Objektverfolgung von VisionEye mit Ultralytics YOLO11 ermöglicht es dem Benutzer, die Bewegung von Objekten innerhalb eines Videobildes zu verfolgen. Zu den wichtigsten Funktionen gehören:
- Objektverfolgung in Echtzeit: Verfolgt Objekte, während sie sich bewegen.
- Objekt-Identifizierung: Nutzt die leistungsstarken Erkennungsalgorithmen von YOLO11.
- Entfernungsberechnung: Berechnet Entfernungen zwischen Objekten und bestimmten Punkten.
- Beschriftung und Visualisierung: Bietet visuelle Markierungen für verfolgte Objekte.
Hier ein kurzer Codeschnipsel zur Demonstration der Verfolgung mit 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()
Einen umfassenden Leitfaden finden Sie in der VisionEye Object Mapping with Object Tracking.
Wie kann ich Entfernungen mit dem Modell YOLO11 von VisionEye berechnen?
Bei der Entfernungsberechnung mit VisionEye und Ultralytics YOLO11 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("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()
Detaillierte Anweisungen finden Sie in der Broschüre VisionEye mit Entfernungsberechnung.
Warum sollte ich Ultralytics YOLO11 für Objektzuordnung und -verfolgung verwenden?
Ultralytics YOLO11 ist bekannt für seine Schnelligkeit, Genauigkeit und einfache Integration, was es zur ersten Wahl für Objektmapping und -verfolgung macht. Die wichtigsten Vorteile sind:
- Leistung auf dem neuesten Stand der Technik: Hohe Genauigkeit bei der Objekterkennung in Echtzeit.
- Flexibel: Unterstützt verschiedene Aufgaben wie Erkennung, Verfolgung und Entfernungsberechnung.
- Gemeinschaft und Unterstützung: Umfangreiche Dokumentation und aktive GitHub-Community für Fehlerbehebung und Erweiterungen.
- Benutzerfreundlichkeit: Intuitive API vereinfacht komplexe Aufgaben und ermöglicht eine schnelle Bereitstellung und Wiederholung.
Weitere Informationen über Anwendungen und Vorteile finden Sie in der DokumentationUltralytics YOLO11 .
Wie kann ich VisionEye mit anderen Machine-Learning-Tools wie Comet oder ClearML integrieren?
Ultralytics YOLO11 kann nahtlos in verschiedene Tools für maschinelles Lernen wie Comet und ClearML integriert werden, wodurch die Verfolgung von Experimenten, die Zusammenarbeit und die Reproduzierbarkeit verbessert werden. Folgen Sie den detaillierten Anleitungen zur Verwendung von YOLOv5 mit Comet und zur Integration von YOLO11 mit ClearML, um loszulegen.
Weitere Informationen und Integrationsbeispiele finden Sie in unserem Ultralytics Integrationsleitfaden.
