yolov8_test/docs/en/guides/heatmaps.md

comments	description	keywords
true	Advanced Data Visualization with Ultralytics YOLOv8 Heatmaps	Ultralytics, YOLOv8, Advanced Data Visualization, Heatmap Technology, Object Detection and Tracking, Jupyter Notebook, Python SDK, Command Line Interface

Advanced Data Visualization: Heatmaps using Ultralytics YOLOv8 🚀

Introduction to Heatmaps

A heatmap generated with Ultralytics YOLOv8 transforms complex data into a vibrant, color-coded matrix. This visual tool employs a spectrum of colors to represent varying data values, where warmer hues indicate higher intensities and cooler tones signify lower values. Heatmaps excel in visualizing intricate data patterns, correlations, and anomalies, offering an accessible and engaging approach to data interpretation across diverse domains.

Watch: Heatmaps using Ultralytics YOLOv8

Why Choose Heatmaps for Data Analysis?

• Intuitive Data Distribution Visualization: Heatmaps simplify the comprehension of data concentration and distribution, converting complex datasets into easy-to-understand visual formats.
• Efficient Pattern Detection: By visualizing data in heatmap format, it becomes easier to spot trends, clusters, and outliers, facilitating quicker analysis and insights.
• Enhanced Spatial Analysis and Decision Making: Heatmaps are instrumental in illustrating spatial relationships, aiding in decision-making processes in sectors such as business intelligence, environmental studies, and urban planning.

Real World Applications

Transportation	Retail
Ultralytics YOLOv8 Transportation Heatmap	Ultralytics YOLOv8 Retail Heatmap

???+ tip "Heatmap Configuration" - heatmap_alpha: Ensure this value is within the range (0.0 - 1.0). - decay_factor: Used for removing heatmap after an object is no longer in the frame, its value should also be in the range (0.0 - 1.0).

!!! Example "Heatmaps using Ultralytics YOLOv8 Example"

=== "Heatmap"
    ```python
    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"

    # Video writer
    video_writer = cv2.VideoWriter("heatmap_output.avi",
                                   cv2.VideoWriter_fourcc(*'mp4v'),
                                   int(cap.get(5)),
                                   (int(cap.get(3)), int(cap.get(4))))

    # Init heatmap
    heatmap_obj = heatmap.Heatmap()
    heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
                         imw=cap.get(4),  # should same as cap height
                         imh=cap.get(3),  # should same as cap width
                         view_img=True,
                         shape="circle")

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

    ```

=== "Line Counting"
    ```python
    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"

    # Video writer
    video_writer = cv2.VideoWriter("heatmap_output.avi",
                                   cv2.VideoWriter_fourcc(*'mp4v'),
                                   int(cap.get(5)),
                                   (int(cap.get(3)), int(cap.get(4))))

    line_points = [(256, 409), (694, 532)]  # line for object counting

    # Init heatmap
    heatmap_obj = heatmap.Heatmap()
    heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
                         imw=cap.get(4),  # should same as cap height
                         imh=cap.get(3),  # should same as cap width
                         view_img=True,
                         shape="circle",
                         count_reg_pts=line_points)

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

=== "Region Counting"
    ```python
    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"

    # Video writer
    video_writer = cv2.VideoWriter("heatmap_output.avi",
                                   cv2.VideoWriter_fourcc(*'mp4v'),
                                   int(cap.get(5)),
                                   (int(cap.get(3)), int(cap.get(4))))

    # 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=cap.get(4),  # should same as cap height
                         imh=cap.get(3),  # should same as cap width
                         view_img=True,
                         shape="circle",
                         count_reg_pts=region_points)

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

=== "Im0"
    ```python
    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

    # Heatmap Init
    heatmap_obj = heatmap.Heatmap()
    heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
                                 imw=im0.shape[0],  # should same as im0 width
                                 imh=im0.shape[1],  # should same as im0 height
                                 view_img=True,
                                 shape="circle")


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

=== "Specific Classes"
    ```python
    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"

    # Video writer
    video_writer = cv2.VideoWriter("heatmap_output.avi",
                                   cv2.VideoWriter_fourcc(*'mp4v'),
                                   int(cap.get(5)),
                                   (int(cap.get(3)), int(cap.get(4))))

    classes_for_heatmap = [0, 2]  # classes for heatmap

    # Init heatmap
    heatmap_obj = heatmap.Heatmap()
    heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
                         imw=cap.get(4),  # should same as cap height
                         imh=cap.get(3),  # should same as cap width
                         view_img=True,
                         shape="circle")

    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 set_args

Name	Type	Default	Description
view_img	bool	False	Display the frame with heatmap
colormap	cv2.COLORMAP	None	cv2.COLORMAP for heatmap
imw	int	None	Width of Heatmap
imh	int	None	Height of Heatmap
heatmap_alpha	float	0.5	Heatmap alpha value
count_reg_pts	list	None	Object counting region points
count_txt_thickness	int	2	Count values text size
count_txt_color	RGB Color	(0, 0, 0)	Foreground color for Object counts text
count_color	RGB Color	(255, 255, 255)	Background color for Object counts text
count_reg_color	RGB Color	(255, 0, 255)	Counting region color
region_thickness	int	5	Counting region thickness value
decay_factor	float	0.99	Decay factor for heatmap area removal after specific time
shape	str	circle	Heatmap shape for display "rect" or "circle" supported
line_dist_thresh	int	15	Euclidean Distance threshold for line counter

Arguments model.track

Name	Type	Default	Description
source	im0	None	source directory for images or videos
persist	bool	False	persisting tracks between frames
tracker	str	botsort.yaml	Tracking method 'bytetrack' or 'botsort'
conf	float	0.3	Confidence Threshold
iou	float	0.5	IOU Threshold
classes	list	None	filter results by class, i.e. classes=0, or classes=[0,2,3]

Heatmap COLORMAPs

Colormap Name	Description
cv::COLORMAP_AUTUMN	Autumn color map
cv::COLORMAP_BONE	Bone color map
cv::COLORMAP_JET	Jet color map
cv::COLORMAP_WINTER	Winter color map
cv::COLORMAP_RAINBOW	Rainbow color map
cv::COLORMAP_OCEAN	Ocean color map
cv::COLORMAP_SUMMER	Summer color map
cv::COLORMAP_SPRING	Spring color map
cv::COLORMAP_COOL	Cool color map
cv::COLORMAP_HSV	HSV (Hue, Saturation, Value) color map
cv::COLORMAP_PINK	Pink color map
cv::COLORMAP_HOT	Hot color map
cv::COLORMAP_PARULA	Parula color map
cv::COLORMAP_MAGMA	Magma color map
cv::COLORMAP_INFERNO	Inferno color map
cv::COLORMAP_PLASMA	Plasma color map
cv::COLORMAP_VIRIDIS	Viridis color map
cv::COLORMAP_CIVIDIS	Cividis color map
cv::COLORMAP_TWILIGHT	Twilight color map
cv::COLORMAP_TWILIGHT_SHIFTED	Shifted Twilight color map
cv::COLORMAP_TURBO	Turbo color map
cv::COLORMAP_DEEPGREEN	Deep Green color map

These colormaps are commonly used for visualizing data with different color representations.