Fortgeschrittene Datenvisualisierung: Heatmaps mit Ultralytics YOLOv8 🚀

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

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     classes_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()

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     count_reg_pts=line_points,
                     classes_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()

from ultralytics import YOLO
import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     count_reg_pts=region_points,
                     classes_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()

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     count_reg_pts=region_points,
                     classes_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()

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     classes_names=model.names)

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

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

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 = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
                     imw=w,
                     imh=h,
                     view_img=True,
                     shape="circle",
                     classes_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 `set_args`

Name	Typ	Standard	Beschreibung
`view_img`	`bool`	`False`	Den Rahmen mit Heatmap anzeigen
`colormap`	`cv2.COLORMAP`	`None`	cv2.COLORMAP für Heatmap
`imw`	`int`	`None`	Breite der Heatmap
`imh`	`int`	`None`	Höhe der Heatmap
`line_thickness`	`int`	`2`	Begrenzungsrahmen vergrößern und Textdicke zählen
`view_in_counts`	`bool`	`True`	Incounts nur auf dem Videobild anzeigen
`view_out_counts`	`bool`	`True`	Out-Counts nur auf dem Videobild anzeigen
`classes_names`	`dict`	`model.model.names`	Wörterbuch der Klassennamen
`heatmap_alpha`	`float`	`0.5`	Heatmap Alpha-Wert
`count_reg_pts`	`list`	`None`	Objekt Zählregion Punkte
`count_txt_color`	`RGB Color`	`(0, 0, 0)`	Vordergrundfarbe für Objekt zählt Text
`count_reg_color`	`RGB Color`	`(255, 0, 255)`	Farbe der Zählregion
`region_thickness`	`int`	`5`	Wert für die Dicke der Zählregion
`decay_factor`	`float`	`0.99`	Abklingfaktor für die Entfernung von Heatmap-Flächen nach einer bestimmten Zeit
`shape`	`str`	`circle`	Heatmap-Form für die Anzeige "Rechteck" oder "Kreis" unterstützt
`line_dist_thresh`	`int`	`15`	Euklidischer Abstand Schwellenwert für Zeilenzähler
`count_bg_color`	`RGB Color`	`(255, 255, 255)`	Textmarkerfarbe zählen
`cls_txtdisplay_gap`	`int`	`50`	Lücke zwischen den einzelnen Klassen anzeigen

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.

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

Fortgeschrittene Datenvisualisierung: Heatmaps mit Ultralytics YOLOv8 🚀

Einführung in Heatmaps

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

Anwendungen in der realen Welt

Argumente set_args

Argumente model.track

Heatmap COLORMAPs

Kommentare

Argumente `set_args`

Argumente `model.track`