Visualizzazione avanzata dei dati: Heatmap con Ultralytics YOLOv8 🚀

Introduzione alle mappe di calore

Una mappa di calore generata con Ultralytics YOLOv8 trasforma dati complessi in una matrice vivace e colorata. Questo strumento visivo utilizza uno spettro di colori per rappresentare i diversi valori dei dati, dove le tonalità più calde indicano intensità più elevate e quelle più fredde valori più bassi. Le heatmap eccellono nella visualizzazione di intricati modelli di dati, correlazioni e anomalie, offrendo un approccio accessibile e coinvolgente all'interpretazione dei dati in diversi ambiti.

Guarda: Mappe di calore con Ultralytics YOLOv8

Perché scegliere le Heatmap per l'analisi dei dati?

Visualizzazione intuitiva della distribuzione dei dati: Le Heatmap semplificano la comprensione della concentrazione e della distribuzione dei dati, convertendo insiemi di dati complessi in formati visivi di facile comprensione.
Rilevamento efficiente dei pattern: Visualizzando i dati in formato heatmap, diventa più facile individuare tendenze, cluster e anomalie, facilitando analisi e approfondimenti più rapidi.
Miglioramento dell'analisi spaziale e del processo decisionale: le mappe di calore sono fondamentali per illustrare le relazioni spaziali, aiutando i processi decisionali in settori come la business intelligence, gli studi ambientali e la pianificazione urbana.

Applicazioni nel mondo reale

Trasporto	Vendita al dettaglio

Ultralytics YOLOv8 Mappa di calore dei trasporti	Ultralytics YOLOv8 Mappa di calore del commercio al dettaglio

Configurazione della mappa di calore

heatmap_alpha: Assicurati che questo valore sia compreso nell'intervallo (0,0 - 1,0).
decay_factor: Utilizzato per rimuovere la mappa di calore dopo che un oggetto non è più presente nell'inquadratura, il suo valore deve essere compreso nell'intervallo (0,0 - 1,0).

Heatmaps con Ultralytics YOLOv8 Esempio

Mappa di caloreConteggio delle lineeConteggio dei poligoniConteggio delle regioniIm0Classi specifiche

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()

Argomenti `set_args`

Nome	Tipo	Predefinito	Descrizione
`view_img`	`bool`	`False`	Visualizza la cornice con la mappa di calore
`colormap`	`cv2.COLORMAP`	`None`	cv2.COLORMAP per la mappa di calore
`imw`	`int`	`None`	Larghezza della mappa di calore
`imh`	`int`	`None`	Altezza della Heatmap
`line_thickness`	`int`	`2`	Aumenta i riquadri di delimitazione e conta lo spessore del testo
`view_in_counts`	`bool`	`True`	Visualizza gli in-conti solo sul fotogramma video
`view_out_counts`	`bool`	`True`	Visualizza gli out-count solo sul fotogramma video
`classes_names`	`dict`	`model.model.names`	Dizionario dei nomi delle classi
`heatmap_alpha`	`float`	`0.5`	Valore alfa della mappa di calore
`count_reg_pts`	`list`	`None`	Punti della regione di conteggio degli oggetti
`count_txt_color`	`RGB Color`	`(0, 0, 0)`	Colore di primo piano per il testo dei conteggi degli oggetti
`count_reg_color`	`RGB Color`	`(255, 0, 255)`	Colore della regione di conteggio
`region_thickness`	`int`	`5`	Valore dello spessore della regione di conteggio
`decay_factor`	`float`	`0.99`	Fattore di decadimento per la rimozione dell'area della mappa di calore dopo un tempo specifico
`shape`	`str`	`circle`	Forma della mappa di calore per la visualizzazione "rect" o "circle" supportata
`line_dist_thresh`	`int`	`15`	Soglia della distanza euclidea per il contatore di linee
`count_bg_color`	`RGB Color`	`(255, 255, 255)`	Conta il colore dell'evidenziatore
`cls_txtdisplay_gap`	`int`	`50`	Visualizza l'intervallo tra il conteggio di ogni classe

Argomenti `model.track`

Nome	Tipo	Predefinito	Descrizione
`source`	`im0`	`None`	directory di origine per le immagini o i video
`persist`	`bool`	`False`	persistenza dei brani tra i fotogrammi
`tracker`	`str`	`botsort.yaml`	Metodo di tracciamento 'bytetrack' o 'botsort'
`conf`	`float`	`0.3`	Soglia di fiducia
`iou`	`float`	`0.5`	Soglia IOU
`classes`	`list`	`None`	filtrare i risultati per classe, ad esempio classi=0 o classi=[0,2,3].

Heatmap COLORMAPs

Nome della mappa dei colori	Descrizione
`cv::COLORMAP_AUTUMN`	Mappa dei colori autunnali
`cv::COLORMAP_BONE`	Mappa dei colori delle ossa
`cv::COLORMAP_JET`	Mappa dei colori del getto
`cv::COLORMAP_WINTER`	Mappa dei colori invernali
`cv::COLORMAP_RAINBOW`	Mappa dei colori dell'arcobaleno
`cv::COLORMAP_OCEAN`	Mappa dei colori dell'oceano
`cv::COLORMAP_SUMMER`	Mappa dei colori estivi
`cv::COLORMAP_SPRING`	Mappa dei colori della primavera
`cv::COLORMAP_COOL`	Una bella mappa a colori
`cv::COLORMAP_HSV`	Mappa di colore HSV (Tonalità, Saturazione, Valore)
`cv::COLORMAP_PINK`	Mappa a colori rosa
`cv::COLORMAP_HOT`	Mappa dei colori caldi
`cv::COLORMAP_PARULA`	Mappa dei colori della Parula
`cv::COLORMAP_MAGMA`	Mappa dei colori del magma
`cv::COLORMAP_INFERNO`	Mappa a colori di Inferno
`cv::COLORMAP_PLASMA`	Mappa dei colori del plasma
`cv::COLORMAP_VIRIDIS`	Mappa a colori di Viridis
`cv::COLORMAP_CIVIDIS`	Mappa a colori di Cividis
`cv::COLORMAP_TWILIGHT`	Mappa a colori del crepuscolo
`cv::COLORMAP_TWILIGHT_SHIFTED`	Mappa dei colori del Crepuscolo spostata
`cv::COLORMAP_TURBO`	Mappa dei colori del turbo
`cv::COLORMAP_DEEPGREEN`	Mappa dei colori verde intenso

Queste mappe di colore sono comunemente utilizzate per visualizzare i dati con rappresentazioni di colori diversi.

Creato 2023-12-07, Aggiornato 2024-04-05
Autori: RizwanMunawar (8), glenn-jocher (7), AyushExel (1), 1579093407@qq.com (1)