Visualização avançada de dados: Heatmaps usando Ultralytics YOLOv8 🚀

Introdução aos mapas de calor

Um mapa de calor gerado com Ultralytics YOLOv8 transforma dados complexos numa matriz vibrante e codificada por cores. Esta ferramenta visual utiliza um espetro de cores para representar valores de dados variáveis, em que os tons mais quentes indicam intensidades mais elevadas e os tons mais frios significam valores mais baixos. Os mapas de calor são excelentes na visualização de padrões de dados intrincados, correlações e anomalias, oferecendo uma abordagem acessível e envolvente à interpretação de dados em diversos domínios.

Observa: Mapas de calor utilizando Ultralytics YOLOv8

Porquê escolher os mapas de calor para a análise de dados?

Visualização intuitiva da distribuição de dados: Os mapas de calor simplificam a compreensão da concentração e distribuição de dados, convertendo conjuntos de dados complexos em formatos visuais fáceis de entender.
Deteção eficiente de padrões: Ao visualizar os dados em formato de mapa de calor, torna-se mais fácil detetar tendências, clusters e outliers, facilitando uma análise mais rápida e insights.
Melhoria da análise espacial e da tomada de decisões: Os mapas de calor são fundamentais para ilustrar as relações espaciais, ajudando nos processos de tomada de decisões em sectores como a inteligência empresarial, os estudos ambientais e o planeamento urbano.

Aplicações no mundo real

Transporte	Retalho

Ultralytics YOLOv8 Mapa de calor dos transportes	Ultralytics YOLOv8 Mapa de calor do retalho

Configuração do mapa de calor

heatmap_alpha: Certifica-te de que este valor se encontra no intervalo (0,0 - 1,0).
decay_factor: Usado para remover o mapa de calor depois de um objeto já não estar no quadro, o seu valor também deve estar no intervalo (0,0 - 1,0).

Mapas de calor utilizando Ultralytics YOLOv8 Exemplo

Mapa de calorContagem de linhasContagem de polígonosContagem de regiõesIm0Classes específicas

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

Argumentos `set_args`

Nome	Tipo	Predefinição	Descrição
`view_img`	`bool`	`False`	Apresenta o quadro com o mapa de calor
`colormap`	`cv2.COLORMAP`	`None`	cv2.COLORMAP para o mapa térmico
`imw`	`int`	`None`	Largura do mapa de calor
`imh`	`int`	`None`	Altura do mapa de calor
`line_thickness`	`int`	`2`	Aumenta as caixas delimitadoras e conta a espessura do texto
`view_in_counts`	`bool`	`True`	Apresenta as contagens iniciais apenas no fotograma de vídeo
`view_out_counts`	`bool`	`True`	Apresenta as contagens totais apenas no fotograma de vídeo
`classes_names`	`dict`	`model.model.names`	Dicionário de nomes de classes
`heatmap_alpha`	`float`	`0.5`	Valor alfa do mapa de calor
`count_reg_pts`	`list`	`None`	Pontos da região de contagem de objectos
`count_txt_color`	`RGB Color`	`(0, 0, 0)`	Cor de primeiro plano para o texto de contagem de objectos
`count_reg_color`	`RGB Color`	`(255, 0, 255)`	Cor da região de contagem
`region_thickness`	`int`	`5`	Valor da espessura da região de contagem
`decay_factor`	`float`	`0.99`	Fator de decaimento para a remoção da área do mapa de calor após um tempo específico
`shape`	`str`	`circle`	Forma do mapa de calor para visualização "rect" ou "círculo" suportada
`line_dist_thresh`	`int`	`15`	Limiar da distância euclidiana para o contador de linhas
`count_bg_color`	`RGB Color`	`(255, 255, 255)`	Conta a cor do marcador
`cls_txtdisplay_gap`	`int`	`50`	Mostra o intervalo entre cada contagem de classes

Argumentos `model.track`

Nome	Tipo	Predefinição	Descrição
`source`	`im0`	`None`	diretório de origem para imagens ou vídeos
`persist`	`bool`	`False`	persistência de faixas entre fotogramas
`tracker`	`str`	`botsort.yaml`	Método de rastreio 'bytetrack' ou 'botsort'
`conf`	`float`	`0.3`	Limiar de confiança
`iou`	`float`	`0.5`	Limiar IOU
`classes`	`list`	`None`	filtra os resultados por classe, ou seja, classes=0, ou classes=[0,2,3]

Mapa térmico COLORMAPs

Nome do mapa de cores	Descrição
`cv::COLORMAP_AUTUMN`	Mapa das cores do outono
`cv::COLORMAP_BONE`	Mapa de cores dos ossos
`cv::COLORMAP_JET`	Mapa de cores do jato
`cv::COLORMAP_WINTER`	Mapa de cores de inverno
`cv::COLORMAP_RAINBOW`	Mapa de cores do arco-íris
`cv::COLORMAP_OCEAN`	Mapa de cores dos oceanos
`cv::COLORMAP_SUMMER`	Mapa de cores do verão
`cv::COLORMAP_SPRING`	Mapa de cores da primavera
`cv::COLORMAP_COOL`	Mapa de cores fixe
`cv::COLORMAP_HSV`	Mapa de cores HSV (Matiz, Saturação, Valor)
`cv::COLORMAP_PINK`	Mapa cor-de-rosa
`cv::COLORMAP_HOT`	Mapa de cores quentes
`cv::COLORMAP_PARULA`	Mapa de cores de Parula
`cv::COLORMAP_MAGMA`	Mapa de cores do magma
`cv::COLORMAP_INFERNO`	Mapa de cores do Inferno
`cv::COLORMAP_PLASMA`	Mapa de cores do plasma
`cv::COLORMAP_VIRIDIS`	Mapa de cores de Viridis
`cv::COLORMAP_CIVIDIS`	Mapa de cores de Cividis
`cv::COLORMAP_TWILIGHT`	Mapa de cores do crepúsculo
`cv::COLORMAP_TWILIGHT_SHIFTED`	Mapa de cores do crepúsculo deslocado
`cv::COLORMAP_TURBO`	Mapa de cores do turbo
`cv::COLORMAP_DEEPGREEN`	Mapa de cores verde profundo

Estes mapas de cores são normalmente utilizados para visualizar dados com diferentes representações de cores.

Criado em 2023-12-07, Atualizado em 2024-04-05
Autores: RizwanMunawar (8), glenn-jocher (7), AyushExel (1), 1579093407@qq.com (1)