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

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

Argomenti `Heatmap()`

Nome	Tipo	Predefinito	Descrizione
`names`	`list`	`None`	Dizionario dei nomi delle classi.
`imw`	`int`	`0`	Larghezza dell'immagine.
`imh`	`int`	`0`	Altezza immagine.
`colormap`	`int`	`cv2.COLORMAP_JET`	Mappa dei colori da utilizzare per la mappa di calore.
`heatmap_alpha`	`float`	`0.5`	Valore di fusione alfa per la sovrapposizione della mappa di calore.
`view_img`	`bool`	`False`	Se visualizzare l'immagine con la sovrapposizione della mappa di calore.
`view_in_counts`	`bool`	`True`	Se visualizzare il conteggio degli oggetti che entrano nella regione.
`view_out_counts`	`bool`	`True`	Se visualizzare il conteggio degli oggetti che escono dalla regione.
`count_reg_pts`	`list` o `None`	`None`	Punti che definiscono la regione di conteggio (una linea o un poligono).
`count_txt_color`	`tuple`	`(0, 0, 0)`	Colore del testo per la visualizzazione dei conteggi.
`count_bg_color`	`tuple`	`(255, 255, 255)`	Colore di sfondo per la visualizzazione dei conteggi.
`count_reg_color`	`tuple`	`(255, 0, 255)`	Colore per la regione di conteggio.
`region_thickness`	`int`	`5`	Spessore della linea della regione.
`line_dist_thresh`	`int`	`15`	Soglia di distanza per il conteggio basato sulle linee.
`line_thickness`	`int`	`2`	Spessore delle linee utilizzate nel disegno.
`decay_factor`	`float`	`0.99`	Fattore di decadimento della mappa di calore per ridurre l'intensità nel tempo.
`shape`	`str`	`"circle"`	Forma dei blob della mappa di calore ("cerchio" o "rettangolo").

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.

DOMANDE FREQUENTI

Come fa Ultralytics YOLOv8 a generare le heatmap e quali sono i loro vantaggi?

Ultralytics YOLOv8 genera mappe di calore trasformando dati complessi in una matrice colorata in cui le diverse tonalità rappresentano le intensità dei dati. Le heatmap rendono più facile la visualizzazione di schemi, correlazioni e anomalie nei dati. Le tonalità più calde indicano valori più alti, mentre quelle più fredde rappresentano valori più bassi. I vantaggi principali sono la visualizzazione intuitiva della distribuzione dei dati, l'individuazione efficiente di modelli e il miglioramento dell'analisi spaziale per il processo decisionale. Per maggiori dettagli e opzioni di configurazione, consulta la sezione Configurazione della Heatmap.

Posso utilizzare Ultralytics YOLOv8 per eseguire il tracciamento degli oggetti e generare contemporaneamente una mappa di calore?

Sì, Ultralytics YOLOv8 supporta il tracciamento degli oggetti e la generazione di mappe di calore in modo simultaneo. Questo può essere ottenuto attraverso il suo Heatmap integrata con i modelli di tracciamento degli oggetti. Per farlo, devi inizializzare l'oggetto heatmap e utilizzare le funzionalità di tracciamento di YOLOv8. Ecco un semplice esempio:

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

Per ulteriori indicazioni, consulta la pagina della modalità di tracciamento.

Cosa rende le heatmap di Ultralytics YOLOv8 diverse da altri strumenti di visualizzazione dei dati come quelli di OpenCV o Matplotlib?

Ultralytics YOLOv8 Le heatmap di sono specificamente progettate per l'integrazione con i suoi modelli di rilevamento e tracciamento degli oggetti, fornendo una soluzione end-to-end per l'analisi dei dati in tempo reale. A differenza di strumenti di visualizzazione generici come OpenCV o Matplotlib, le heatmap di YOLOv8 sono ottimizzate per le prestazioni e l'elaborazione automatica, supportando funzioni come il tracciamento persistente, la regolazione del fattore di decadimento e la sovrapposizione di video in tempo reale. Per maggiori informazioni sulle caratteristiche uniche di YOLOv8, visita la pagina Ultralytics YOLOv8 Introduzione.

Come posso visualizzare solo classi di oggetti specifici nelle heatmap utilizzando Ultralytics YOLOv8 ?

Puoi visualizzare classi di oggetti specifiche specificando le classi desiderate nel campo track() del modello YOLO . Ad esempio, se vuoi visualizzare solo le automobili e le persone (supponendo che i loro indici di classe siano 0 e 2), puoi impostare il metodo classes di conseguenza.

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

Perché le aziende dovrebbero scegliere Ultralytics YOLOv8 per la generazione di mappe di calore nell'analisi dei dati?

Ultralytics YOLOv8 offre una perfetta integrazione tra il rilevamento avanzato degli oggetti e la generazione di mappe di calore in tempo reale, rendendola la scelta ideale per le aziende che desiderano visualizzare i dati in modo più efficace. I vantaggi principali includono la visualizzazione intuitiva della distribuzione dei dati, il rilevamento efficiente dei modelli e l'analisi spaziale migliorata per migliorare il processo decisionale. Inoltre, le caratteristiche all'avanguardia di YOLOv8, come il tracciamento persistente, le mappe di colore personalizzabili e il supporto di vari formati di esportazione, lo rendono superiore ad altri strumenti come TensorFlow e OpenCV per un'analisi completa dei dati. Per saperne di più sulle applicazioni aziendali, visita i piani diUltralytics .

Creato 2023-12-07, Aggiornato 2024-07-14
Autori: RizwanMunawar (8), glenn-jocher (13), IvorZhu331 (1), AyushExel (1), 1579093407@qq.com (1)