Visualisation avancée des données : Cartes thermiques à l'aide de Ultralytics YOLOv8 🚀

Introduction aux cartes thermiques

Une carte thermique générée avec Ultralytics YOLOv8 transforme des données complexes en une matrice vibrante, codée par couleur. Cet outil visuel utilise un spectre de couleurs pour représenter les valeurs variables des données, les teintes plus chaudes indiquant des intensités plus élevées et les tons plus froids des valeurs plus faibles. Les cartes thermiques excellent dans la visualisation de modèles de données complexes, de corrélations et d'anomalies, offrant une approche accessible et attrayante de l'interprétation des données dans divers domaines.

Regarde : Cartes thermiques utilisant Ultralytics YOLOv8

Pourquoi choisir les cartes thermiques pour l'analyse des données ?

Visualisation intuitive de la distribution des données : Les cartes thermiques simplifient la compréhension de la concentration et de la distribution des données, en convertissant des ensembles de données complexes en formats visuels faciles à comprendre.
Détection efficace des tendances : En visualisant les données sous forme de carte thermique, il devient plus facile de repérer les tendances, les grappes et les valeurs aberrantes, ce qui facilite une analyse et des idées plus rapides.
Amélioration de l'analyse spatiale et de la prise de décision : les cartes thermiques permettent d'illustrer les relations spatiales et de faciliter les processus de prise de décision dans des secteurs tels que l'intelligence économique, les études environnementales et l'urbanisme.

Applications dans le monde réel

Transport	Vente au détail

Ultralytics YOLOv8 Carte thermique des transports	Ultralytics YOLOv8 Carte thermique du commerce de détail

Configuration de la carte thermique

heatmap_alpha: Assure-toi que cette valeur est comprise dans la plage (0,0 - 1,0).
decay_factor: Utilisé pour supprimer la carte thermique après qu'un objet n'est plus dans le cadre, sa valeur doit également être comprise dans la plage (0,0 - 1,0).

Cartes thermiques à l'aide de Ultralytics YOLOv8 Exemple

Carte thermiqueCompter les lignesComptage des polygonesComptage des régionsIm0Classes spécifiques

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

Arguments `Heatmap()`

Nom	Type	Défaut	Description
`names`	`list`	`None`	Dictionnaire des noms de classes.
`imw`	`int`	`0`	Largeur de l'image.
`imh`	`int`	`0`	Hauteur de l'image.
`colormap`	`int`	`cv2.COLORMAP_JET`	Carte de couleurs à utiliser pour la carte thermique.
`heatmap_alpha`	`float`	`0.5`	Valeur de mélange alpha pour la superposition de la carte thermique.
`view_img`	`bool`	`False`	Permet d'afficher ou non l'image avec la superposition de la carte thermique.
`view_in_counts`	`bool`	`True`	Affiche ou non le nombre d'objets entrant dans la région.
`view_out_counts`	`bool`	`True`	Affiche ou non le nombre d'objets qui sortent de la région.
`count_reg_pts`	`list` ou `None`	`None`	Points définissant la région de comptage (soit une ligne, soit un polygone).
`count_txt_color`	`tuple`	`(0, 0, 0)`	Couleur du texte pour l'affichage des comptages.
`count_bg_color`	`tuple`	`(255, 255, 255)`	Couleur d'arrière-plan pour l'affichage des comptes.
`count_reg_color`	`tuple`	`(255, 0, 255)`	Couleur pour la région de comptage.
`region_thickness`	`int`	`5`	Épaisseur de la ligne de la région.
`line_dist_thresh`	`int`	`15`	Seuil de distance pour le comptage basé sur les lignes.
`line_thickness`	`int`	`2`	Épaisseur des lignes utilisées pour le dessin.
`decay_factor`	`float`	`0.99`	Facteur de décroissance de la carte thermique pour réduire l'intensité au fil du temps.
`shape`	`str`	`"circle"`	Forme des taches de la carte thermique ('cercle' ou 'rect').

Arguments `model.track`

Nom	Type	Défaut	Description
`source`	`im0`	`None`	répertoire source pour les images ou les vidéos
`persist`	`bool`	`False`	persistance des pistes entre les images
`tracker`	`str`	`botsort.yaml`	Méthode de suivi 'bytetrack' ou 'botsort'
`conf`	`float`	`0.3`	Seuil de confiance
`iou`	`float`	`0.5`	Seuil de reconnaissance de dette
`classes`	`list`	`None`	filtre les résultats par classe, c'est-à-dire classes=0, ou classes=[0,2,3]

Carte thermique COLORMAPs

Nom de la carte de couleurs	Description
`cv::COLORMAP_AUTUMN`	Carte des couleurs d'automne
`cv::COLORMAP_BONE`	Carte des couleurs des os
`cv::COLORMAP_JET`	Carte des couleurs du jet
`cv::COLORMAP_WINTER`	Carte des couleurs de l'hiver
`cv::COLORMAP_RAINBOW`	Carte des couleurs de l'arc-en-ciel
`cv::COLORMAP_OCEAN`	Carte des couleurs de l'océan
`cv::COLORMAP_SUMMER`	Carte des couleurs de l'été
`cv::COLORMAP_SPRING`	Carte des couleurs du printemps
`cv::COLORMAP_COOL`	Superbe carte des couleurs
`cv::COLORMAP_HSV`	Carte de couleurs HSV (teinte, saturation, valeur)
`cv::COLORMAP_PINK`	Carte en couleur rose
`cv::COLORMAP_HOT`	Carte des couleurs chaudes
`cv::COLORMAP_PARULA`	Carte des couleurs de Parula
`cv::COLORMAP_MAGMA`	Carte des couleurs du magma
`cv::COLORMAP_INFERNO`	Carte des couleurs d'Inferno
`cv::COLORMAP_PLASMA`	Carte des couleurs du plasma
`cv::COLORMAP_VIRIDIS`	Carte des couleurs de Viridis
`cv::COLORMAP_CIVIDIS`	Carte des couleurs de Cividis
`cv::COLORMAP_TWILIGHT`	Carte couleur du crépuscule
`cv::COLORMAP_TWILIGHT_SHIFTED`	Carte des couleurs du crépuscule décalé
`cv::COLORMAP_TURBO`	Carte des couleurs du turbo
`cv::COLORMAP_DEEPGREEN`	Carte des couleurs du vert profond

Ces cartes de couleurs sont couramment utilisées pour visualiser les données avec des représentations de couleurs différentes.

FAQ

Comment Ultralytics YOLOv8 génère-t-il des cartes thermiques et quels sont leurs avantages ?

Ultralytics YOLOv8 génère des cartes thermiques en transformant des données complexes en une matrice codée par couleur où les différentes teintes représentent l'intensité des données. Les cartes thermiques facilitent la visualisation des modèles, des corrélations et des anomalies dans les données. Les teintes plus chaudes indiquent des valeurs plus élevées, tandis que les tons plus froids représentent des valeurs plus faibles. Les principaux avantages sont la visualisation intuitive de la distribution des données, la détection efficace des schémas et l'amélioration de l'analyse spatiale pour la prise de décision. Pour plus de détails et d'options de configuration, reporte-toi à la section Configuration de la carte thermique.

Puis-je utiliser Ultralytics YOLOv8 pour effectuer un suivi d'objet et générer une carte thermique simultanément ?

Oui, Ultralytics YOLOv8 prend en charge le suivi d'objets et la génération de cartes thermiques simultanément. Ceci peut être réalisé grâce à son Heatmap intégrée aux modèles de suivi des objets. Pour ce faire, tu dois initialiser l'objet heatmap et utiliser les capacités de suivi de YOLOv8. Voici un exemple simple :

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

Pour plus de conseils, consulte la page sur le mode de suivi.

Qu'est-ce qui différencie Ultralytics YOLOv8 heatmaps des autres outils de visualisation de données comme ceux d'OpenCV ou de Matplotlib ?

Ultralytics YOLOv8 Les cartes thermiques sont spécialement conçues pour être intégrées à ses modèles de détection et de suivi des objets, offrant ainsi une solution de bout en bout pour l'analyse des données en temps réel. Contrairement aux outils de visualisation génériques comme OpenCV ou Matplotlib, YOLOv8 heatmaps est optimisé pour les performances et le traitement automatisé, et prend en charge des fonctions telles que le suivi persistant, l'ajustement du facteur de décroissance et la superposition de vidéos en temps réel. Pour plus d'informations sur les caractéristiques uniques de YOLOv8, visite le site Ultralytics YOLOv8 Introduction.

Comment puis-je visualiser uniquement des classes d'objets spécifiques dans les cartes thermiques à l'aide de Ultralytics YOLOv8 ?

Tu peux visualiser des classes d'objets spécifiques en spécifiant les classes souhaitées dans la rubrique track() du modèle YOLO . Par exemple, si tu ne veux visualiser que les voitures et les personnes (en supposant que leurs indices de classe sont 0 et 2), tu peux définir le paramètre classes en conséquence.

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

Pourquoi les entreprises devraient-elles choisir Ultralytics YOLOv8 pour la génération de cartes thermiques dans l'analyse des données ?

Ultralytics YOLOv8 offre une intégration transparente de la détection avancée d'objets et de la génération de cartes thermiques en temps réel, ce qui en fait un choix idéal pour les entreprises qui cherchent à visualiser les données plus efficacement. Les principaux avantages comprennent la visualisation intuitive de la distribution des données, la détection efficace des motifs et l'analyse spatiale améliorée pour une meilleure prise de décision. En outre, les fonctions de pointe de YOLOv8, telles que le suivi persistant, les cartes de couleurs personnalisables et la prise en charge de divers formats d'exportation, le rendent supérieur à d'autres outils tels que TensorFlow et OpenCV pour l'analyse complète des données. Pour en savoir plus sur les applications professionnelles, consulte le site Ultralytics Plans.

Créé le 2023-12-07, Mis à jour le 2024-07-14
Auteurs : RizwanMunawar (8), glenn-jocher (13), IvorZhu331 (1), AyushExel (1), 1579093407@qq.com (1)