उन्नत डेटा विज़ुअलाइज़ेशन: हीटमैप्स का उपयोग कर Ultralytics YOLOv8 🚀

हीटमैप्स का परिचय

के साथ उत्पन्न एक हीटमैप Ultralytics YOLOv8 जटिल डेटा को एक जीवंत, रंग-कोडित मैट्रिक्स में बदल देता है। यह दृश्य उपकरण अलग-अलग डेटा मूल्यों का प्रतिनिधित्व करने के लिए रंगों के एक स्पेक्ट्रम को नियोजित करता है, जहां गर्म रंग उच्च तीव्रता का संकेत देते हैं और कूलर टोन कम मूल्यों को दर्शाते हैं। हीटमैप्स जटिल डेटा पैटर्न, सहसंबंधों और विसंगतियों की कल्पना करने में उत्कृष्टता प्राप्त करते हैं, जो विविध डोमेन में डेटा व्याख्या के लिए एक सुलभ और आकर्षक दृष्टिकोण प्रदान करते हैं।

सतर्कता: हीटमैप्स का उपयोग कर Ultralytics YOLOv8

डेटा विश्लेषण के लिए हीटमैप क्यों चुनें?

सहज डेटा वितरण विज़ुअलाइज़ेशन: हीटमैप डेटा एकाग्रता और वितरण की समझ को सरल बनाते हैं, जटिल डेटासेट को आसानी से समझने वाले दृश्य प्रारूपों में परिवर्तित करते हैं।
कुशल पैटर्न का पता लगाने: हीटमैप प्रारूप में डेटा की कल्पना करके, रुझानों, समूहों और आउटलेयर को स्पॉट करना आसान हो जाता है, जिससे त्वरित विश्लेषण और अंतर्दृष्टि की सुविधा मिलती है।
उन्नत स्थानिक विश्लेषण और निर्णय लेना: हीटमैप्स स्थानिक संबंधों को दर्शाने में महत्वपूर्ण भूमिका निभाते हैं, व्यापार खुफिया, पर्यावरण अध्ययन और शहरी नियोजन जैसे क्षेत्रों में निर्णय लेने की प्रक्रियाओं में सहायता करते हैं।

वास्तविक दुनिया अनुप्रयोग

परिवहन	फुटकर

Ultralytics YOLOv8 परिवहन हीटमैप	Ultralytics YOLOv8 खुदरा हीटमैप

हीटमैप कॉन्फ़िगरेशन

heatmap_alpha: सुनिश्चित करें कि यह मान सीमा (0.0 - 1.0) के भीतर है।
decay_factor: किसी वस्तु के फ्रेम में नहीं होने के बाद हीटमैप को हटाने के लिए उपयोग किया जाता है, इसका मान भी सीमा (0.0 - 1.0) में होना चाहिए।

हीटमैप्स का उपयोग कर Ultralytics YOLOv8 उदाहरण

हीटमैपलाइन काउंटिंगबहुभुज की गिनतीक्षेत्र की गिनतीआईएम0विशिष्ट वर्ग

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

तर्क `set_args`

नाम	प्रकार	चूक	या क़िस्‍म
`view_img`	`bool`	`False`	हीटमैप के साथ फ़्रेम प्रदर्शित करें
`colormap`	`cv2.COLORMAP`	`None`	सीवी2. हीटमैप के लिए COLORMAP
`imw`	`int`	`None`	हीटमैप की चौड़ाई
`imh`	`int`	`None`	हीटमैप की ऊंचाई
`line_thickness`	`int`	`2`	बाउंडिंग बॉक्स बढ़ाएँ और टेक्स्ट की मोटाई गिनें
`view_in_counts`	`bool`	`True`	केवल वीडियो फ़्रेम पर इन-काउंट प्रदर्शित करें
`view_out_counts`	`bool`	`True`	केवल वीडियो फ़्रेम पर आउट-काउंट प्रदर्शित करें
`classes_names`	`dict`	`model.model.names`	वर्ग नामों का शब्दकोश
`heatmap_alpha`	`float`	`0.5`	हीटमैप अल्फा मान
`count_reg_pts`	`list`	`None`	ऑब्जेक्ट गिनती क्षेत्र अंक
`count_txt_color`	`RGB Color`	`(0, 0, 0)`	ऑब्जेक्ट काउंट पाठ के लिए अग्रभूमि रंग
`count_reg_color`	`RGB Color`	`(255, 0, 255)`	गिनती क्षेत्र रंग
`region_thickness`	`int`	`5`	क्षेत्र मोटाई मूल्य की गिनती
`decay_factor`	`float`	`0.99`	विशिष्ट समय के बाद हीटमैप क्षेत्र हटाने के लिए क्षय कारक
`shape`	`str`	`circle`	प्रदर्शन "रक्ट" या "सर्कल" समर्थित के लिए हीटमैप आकार
`line_dist_thresh`	`int`	`15`	लाइन काउंटर के लिए यूक्लिडियन दूरी सीमा
`count_bg_color`	`RGB Color`	`(255, 255, 255)`	हाइलाइटर रंग की गणना करें
`cls_txtdisplay_gap`	`int`	`50`	प्रत्येक वर्ग गणना के बीच अंतर प्रदर्शित करें

तर्क `model.track`

नाम	प्रकार	चूक	या क़िस्‍म
`source`	`im0`	`None`	छवियों या वीडियो के लिए स्रोत निर्देशिका
`persist`	`bool`	`False`	फ़्रेम के बीच लगातार ट्रैक
`tracker`	`str`	`botsort.yaml`	ट्रैकिंग विधि 'बाइटट्रैक' या 'बॉटसॉर्ट'
`conf`	`float`	`0.3`	कॉन्फिडेंस थ्रेशोल्ड
`iou`	`float`	`0.5`	IOU थ्रेसहोल्ड
`classes`	`list`	`None`	कक्षा द्वारा फ़िल्टर परिणाम, यानी कक्षाएं = 0, या कक्षाएं = [0,2,3]

हीटमैप COLORMAPs

कलरमैप का नाम	या क़िस्‍म
`cv::COLORMAP_AUTUMN`	शरद ऋतु रंग का नक्शा
`cv::COLORMAP_BONE`	हड्डी के रंग का नक्शा
`cv::COLORMAP_JET`	जेट रंग मानचित्र
`cv::COLORMAP_WINTER`	शीतकालीन रंग मानचित्र
`cv::COLORMAP_RAINBOW`	इंद्रधनुष रंग का नक्शा
`cv::COLORMAP_OCEAN`	महासागर रंग मानचित्र
`cv::COLORMAP_SUMMER`	ग्रीष्मकालीन रंग मानचित्र
`cv::COLORMAP_SPRING`	वसंत रंग का नक्शा
`cv::COLORMAP_COOL`	कूल रंग का नक्शा
`cv::COLORMAP_HSV`	HSV (ह्यू, संतृप्ति, मूल्य) रंग मानचित्र
`cv::COLORMAP_PINK`	गुलाबी रंग का नक्शा
`cv::COLORMAP_HOT`	गर्म रंग का नक्शा
`cv::COLORMAP_PARULA`	परुला रंग मानचित्र
`cv::COLORMAP_MAGMA`	मैग्मा रंग मानचित्र
`cv::COLORMAP_INFERNO`	नरक रंग नक्शा
`cv::COLORMAP_PLASMA`	प्लाज्मा रंग मानचित्र
`cv::COLORMAP_VIRIDIS`	विरिडिस रंग मानचित्र
`cv::COLORMAP_CIVIDIS`	Cividis रंग मानचित्र
`cv::COLORMAP_TWILIGHT`	गोधूलि रंग नक्शा
`cv::COLORMAP_TWILIGHT_SHIFTED`	स्थानांतरित गोधूलि रंग नक्शा
`cv::COLORMAP_TURBO`	टर्बो रंग का नक्शा
`cv::COLORMAP_DEEPGREEN`	गहरा हरा रंग नक्शा

ये कलरमैप आमतौर पर विभिन्न रंग अभ्यावेदन के साथ डेटा को विज़ुअलाइज़ करने के लिए उपयोग किए जाते हैं।

2023-12-07 बनाया गया, अपडेट किया गया 2024-04-05
लेखक: रिजवानमुनव्वर (8), ग्लेन-जोचर (7), आयुषएक्सेल (1), 1579093407@qq.com (1)