Fortgeschrittene Datenvisualisierung: Heatmaps mit Ultralytics YOLOv8 🚀

Q: Can I use Ultralytics YOLOv8 to perform object tracking and generate a heatmap simultaneously?

Ja, Ultralytics YOLOv8 unterstützt die gleichzeitige Erstellung von Objektverfolgung und Heatmaps. Dies kann durch die Heatmap-Lösung erreicht werden, die in das Objektverfolgungsmodell integriert ist. Dazu musst du das Heatmap-Objekt initialisieren und die Tracking-Funktionen von YOLOv8 nutzen. Hier ist ein einfaches Beispiel: Weitere Anleitungen findest du auf der Seite Tracking-Modus.

Einführung in Heatmaps

Eine Heatmap, die mit Ultralytics YOLOv8 erstellt wird, verwandelt komplexe Daten in eine lebendige, farbcodierte Matrix. Dieses visuelle Werkzeug verwendet ein Farbspektrum, um unterschiedliche Datenwerte darzustellen, wobei wärmere Farbtöne für höhere Intensitäten und kühlere Töne für niedrigere Werte stehen. Heatmaps eignen sich hervorragend zur Visualisierung komplexer Datenmuster, Korrelationen und Anomalien und bieten einen zugänglichen und ansprechenden Ansatz für die Interpretation von Daten in verschiedenen Bereichen.

Pass auf: Heatmaps mit Ultralytics YOLOv8

Warum sollten wir Heatmaps für die Datenanalyse wählen?

Intuitive Visualisierung der Datenverteilung: Heatmaps vereinfachen das Verständnis der Datenkonzentration und -verteilung und wandeln komplexe Datensätze in leicht verständliche visuelle Formate um.
Effiziente Erkennung von Mustern: Durch die Visualisierung der Daten im Heatmap-Format ist es einfacher, Trends, Cluster und Ausreißer zu erkennen, was schnellere Analysen und Erkenntnisse ermöglicht.
Verbesserte räumliche Analyse und Entscheidungsfindung: Heatmaps dienen der Veranschaulichung räumlicher Zusammenhänge und helfen bei Entscheidungsprozessen in Bereichen wie Business Intelligence, Umweltstudien und Stadtplanung.

Anwendungen in der realen Welt

Transport	Einzelhandel

Ultralytics YOLOv8 Transport Heatmap	Ultralytics YOLOv8 Einzelhandel Heatmap

Heatmap-Konfiguration

heatmap_alpha: Achte darauf, dass dieser Wert innerhalb des Bereichs (0,0 - 1,0) liegt.
decay_factor: Wird verwendet, um die Heatmap zu entfernen, wenn ein Objekt nicht mehr im Bild ist. Der Wert sollte ebenfalls im Bereich (0,0 - 1,0) liegen.

Heatmaps mit Ultralytics YOLOv8 Beispiel

HeatmapLinienzählungPolygon-ZählungRegion ZählungIm0Besondere Klassen

import cv2

from ultralytics import YOLO, solutions

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

# Video writer
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False)

    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

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

# Video writer
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

line_points = [(20, 400), (1080, 404)]  # line for object counting

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=line_points,
    names=model.names,
)

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

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

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

# Video writer
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Define polygon points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360), (20, 400)]

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=region_points,
    names=model.names,
)

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

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

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

# Video writer
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Define region points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=region_points,
    names=model.names,
)

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

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")  # YOLOv8 custom/pretrained model

im0 = cv2.imread("path/to/image.png")  # path to image file
h, w = im0.shape[:2]  # image height and width

# Heatmap Init
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

results = model.track(im0, persist=True)
im0 = heatmap_obj.generate_heatmap(im0, tracks=results)
cv2.imwrite("ultralytics_output.png", im0)

import cv2

from ultralytics import YOLO, solutions

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

# Video writer
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

classes_for_heatmap = [0, 2]  # classes for heatmap

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False, classes=classes_for_heatmap)

    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

Argumente `Heatmap()`

Name	Typ	Standard	Beschreibung
`names`	`list`	`None`	Wörterbuch der Klassennamen.
`imw`	`int`	`0`	Bildbreite.
`imh`	`int`	`0`	Bildhöhe.
`colormap`	`int`	`cv2.COLORMAP_JET`	Farbkarte, die für die Heatmap verwendet werden soll.
`heatmap_alpha`	`float`	`0.5`	Alpha-Blending-Wert für die Überlagerung der Heatmap.
`view_img`	`bool`	`False`	Ob das Bild mit dem Heatmap-Overlay angezeigt werden soll.
`view_in_counts`	`bool`	`True`	Ob die Anzahl der Objekte angezeigt werden soll, die die Region betreten.
`view_out_counts`	`bool`	`True`	Ob die Anzahl der Objekte, die die Region verlassen, angezeigt werden soll.
`count_reg_pts`	`list` oder `None`	`None`	Punkte, die den Zählbereich definieren (entweder eine Linie oder ein Polygon).
`count_txt_color`	`tuple`	`(0, 0, 0)`	Textfarbe für die Anzeige der Zählungen.
`count_bg_color`	`tuple`	`(255, 255, 255)`	Hintergrundfarbe für die Anzeige der Zählungen.
`count_reg_color`	`tuple`	`(255, 0, 255)`	Farbe für die Zählregion.
`region_thickness`	`int`	`5`	Die Dicke der Regionslinie.
`line_dist_thresh`	`int`	`15`	Abstandsschwelle für die zeilenbasierte Zählung.
`line_thickness`	`int`	`2`	Dicke der beim Zeichnen verwendeten Linien.
`decay_factor`	`float`	`0.99`	Abklingfaktor für die Heatmap, um die Intensität mit der Zeit zu verringern.
`shape`	`str`	`"circle"`	Form der Heatmap-Blobs ("Kreis" oder "Rechteck").

Argumente `model.track`

Name	Typ	Standard	Beschreibung
`source`	`im0`	`None`	Quellverzeichnis für Bilder oder Videos
`persist`	`bool`	`False`	Spuren zwischen Frames beibehalten
`tracker`	`str`	`botsort.yaml`	Tracking-Methode 'bytetrack' oder 'botsort'
`conf`	`float`	`0.3`	Konfidenzschwelle
`iou`	`float`	`0.5`	IOU-Schwelle
`classes`	`list`	`None`	Ergebnisse nach Klassen filtern, d.h. classes=0, oder classes=[0,2,3]

Heatmap COLORMAPs

Colormap Name	Beschreibung
`cv::COLORMAP_AUTUMN`	Farbkarte Herbst
`cv::COLORMAP_BONE`	Knochen-Farbkarte
`cv::COLORMAP_JET`	Jet-Farbkarte
`cv::COLORMAP_WINTER`	Farbkarte Winter
`cv::COLORMAP_RAINBOW`	Regenbogen-Farbkarte
`cv::COLORMAP_OCEAN`	Farbkarte Ozean
`cv::COLORMAP_SUMMER`	Sommer Farbkarte
`cv::COLORMAP_SPRING`	Farbkarte Frühling
`cv::COLORMAP_COOL`	Coole Farbkarte
`cv::COLORMAP_HSV`	HSV (Farbton, Sättigung, Wert) Farbkarte
`cv::COLORMAP_PINK`	Rosa Farbkarte
`cv::COLORMAP_HOT`	Heiße Farbkarte
`cv::COLORMAP_PARULA`	Parula Farbkarte
`cv::COLORMAP_MAGMA`	Magma Farbkarte
`cv::COLORMAP_INFERNO`	Inferno Farbkarte
`cv::COLORMAP_PLASMA`	Plasma-Farbkarte
`cv::COLORMAP_VIRIDIS`	Viridis Farbkarte
`cv::COLORMAP_CIVIDIS`	Cividis Farbkarte
`cv::COLORMAP_TWILIGHT`	Farbkarte der Dämmerung
`cv::COLORMAP_TWILIGHT_SHIFTED`	Verschobene Farbkarte der Dämmerung
`cv::COLORMAP_TURBO`	Turbo Farbkarte
`cv::COLORMAP_DEEPGREEN`	Deep Green Farbkarte

Diese Farbkarten werden häufig zur Visualisierung von Daten mit verschiedenen Farbdarstellungen verwendet.

FAQ

Wie erstellt Ultralytics YOLOv8 Heatmaps und was sind ihre Vorteile?

Ultralytics YOLOv8 erzeugt Heatmaps, indem es komplexe Daten in eine farbkodierte Matrix umwandelt, in der verschiedene Farbtöne die Datenintensität darstellen. Heatmaps machen es einfacher, Muster, Korrelationen und Anomalien in den Daten zu visualisieren. Wärmere Farbtöne zeigen höhere Werte an, während kühlere Töne niedrigere Werte darstellen. Zu den wichtigsten Vorteilen gehören die intuitive Visualisierung der Datenverteilung, die effiziente Erkennung von Mustern und eine verbesserte räumliche Analyse für die Entscheidungsfindung. Weitere Details und Konfigurationsoptionen findest du im Abschnitt Heatmap-Konfiguration.

Kann ich mit Ultralytics YOLOv8 gleichzeitig eine Objektverfolgung durchführen und eine Heatmap erstellen?

Ja, Ultralytics YOLOv8 unterstützt die gleichzeitige Verfolgung von Objekten und die Erstellung von Heatmaps. Dies kann durch seine Heatmap Lösung mit Objektverfolgungsmodellen integriert. Dazu musst du das Heatmap-Objekt initialisieren und die Tracking-Funktionen von YOLOv8 nutzen. Hier ist ein einfaches Beispiel:

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
heatmap_obj = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, view_img=True, shape="circle", names=model.names)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    cv2.imshow("Heatmap", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Weitere Hinweise findest du auf der Seite Tracking-Modus.

Was unterscheidet Ultralytics YOLOv8 Heatmaps von anderen Datenvisualisierungstools wie denen von OpenCV oder Matplotlib?

Ultralytics YOLOv8 Heatmaps wurden speziell für die Integration mit den Objekterkennungs- und -verfolgungsmodellen entwickelt und bieten eine Komplettlösung für die Datenanalyse in Echtzeit. Im Gegensatz zu allgemeinen Visualisierungstools wie OpenCV oder Matplotlib sind YOLOv8 Heatmaps für Leistung und automatisierte Verarbeitung optimiert und unterstützen Funktionen wie persistentes Tracking, Anpassung des Abklingfaktors und Video-Overlay in Echtzeit. Weitere Informationen zu den einzigartigen Funktionen von YOLOv8 findest du in der Ultralytics YOLOv8 Einführung.

Wie kann ich mit Ultralytics YOLOv8 nur bestimmte Objektklassen in Heatmaps visualisieren?

Du kannst bestimmte Objektklassen visualisieren, indem du die gewünschten Klassen in der track() Methode des YOLO Modells. Wenn du zum Beispiel nur Autos und Personen visualisieren möchtest (unter der Annahme, dass ihre Klassenindizes 0 und 2 sind), kannst du die classes Parameter entsprechend anpassen.

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
heatmap_obj = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, view_img=True, shape="circle", names=model.names)

classes_for_heatmap = [0, 2]  # Classes to visualize
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False, classes=classes_for_heatmap)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    cv2.imshow("Heatmap", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Warum sollten Unternehmen Ultralytics YOLOv8 für die Erstellung von Heatmaps bei der Datenanalyse wählen?

Ultralytics YOLOv8 bietet eine nahtlose Integration von fortschrittlicher Objekterkennung und Echtzeit-Heatmap-Generierung und ist damit die ideale Wahl für Unternehmen, die ihre Daten effektiver visualisieren möchten. Zu den wichtigsten Vorteilen gehören die intuitive Visualisierung der Datenverteilung, die effiziente Erkennung von Mustern und die verbesserte räumliche Analyse für bessere Entscheidungen. Darüber hinaus ist YOLOv8 mit seinen innovativen Funktionen wie persistentem Tracking, anpassbaren Colormaps und der Unterstützung verschiedener Exportformate anderen Tools wie TensorFlow und OpenCV für umfassende Datenanalysen überlegen. Erfahre mehr über Geschäftsanwendungen unter Ultralytics Pläne.

Erstellt am 2023-12-07, Aktualisiert am 2024-07-14
Autoren: RizwanMunawar (8), glenn-jocher (13), IvorZhu331 (1), AyushExel (1), 1579093407@qq.com (1)