How can I improve the visibility and behavior of the heatmap color changes in the HeatMapAnnotator class when dealing with a narrow range of heat values?

[vipinap98]

Search before asking

• I have searched the Supervision issues and found no similar feature requests.

Question

I'm working on a project where I need to visualize the heat signatures of people's movement in a lobby area using a heatmap. I'm using the HeatMapAnnotator class from the supervision library, but I'm having trouble getting the heatmap colors to change noticeably, especially when the range of heat values is relatively narrow.

I've tried adjusting various parameters, such as the hue range (top_hue and low_hue), opacity, kernel size, and normalization functions, but the color changes are still not as visible as I'd like them to be. I suspect that the narrow range of heat values in my scenario might be the root cause of this issue.

Here's the current implementation of the annotate method in the HeatMapAnnotator class, along with the modifications I've made,

def annotate(self, scene: np.ndarray, detections: Detections, heat_mask: Optional[np.ndarray] = None) -> Tuple[np.ndarray, np.ndarray]:
    if heat_mask is None:
        heat_mask = np.zeros(scene.shape[:2])

    mask = np.zeros(scene.shape[:2])
    for xy in detections.get_anchors_coordinates(self.position):
        cv2.circle(mask, (int(xy[0]), int(xy[1])), self.radius, 1, -1)

    # Accumulate heat over time with decay
    decay_factor = 0.9  # Adjust this value to control heat decay
    heat_mask = heat_mask * decay_factor + mask

    temp = heat_mask.copy()
    max_value = temp.max()

    if max_value > 0 and not np.isnan(max_value):
        # Normalize heat values using a non-linear function
        temp = np.log(1 + temp / max_value)

        # Assign hue values based on the normalized heat values
        temp = self.top_hue + temp * (self.low_hue - self.top_hue)
    else:
        temp = np.zeros_like(temp)

    temp = temp.astype(np.uint8)

    if self.kernel_size is not None:
        temp = cv2.blur(temp, (self.kernel_size, self.kernel_size))

    hsv = np.zeros(scene.shape, dtype=np.uint8)
    hsv[..., 0] = temp
    hsv[..., 1] = 255
    hsv[..., 2] = 255
    temp = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)

    mask = cv2.cvtColor(heat_mask.astype(np.uint8), cv2.COLOR_GRAY2BGR) > 0
    scene[mask] = cv2.addWeighted(temp, self.opacity, scene, 1 - self.opacity, 0)[mask]

    return scene, heat_mask

Steps Taken:

I've tried adjusting the top_hue and low_hue values to different ranges, such as top_hue=30 (orange) and low_hue=120 (green-blue), to cover a wider range of colors.
I've increased the opacity value to 0.8 and the kernel_size value to 45 to make the heatmap more visible and the color transition smoother.
I've tried using a logarithmic normalization function (temp = np.log(1 + temp / max_value)) instead of the linear normalization, as suggested.

this is how am using the class

heat_map_annotator = HeatMapAnnotator(
            position=sv.Position.BOTTOM_CENTER,
            opacity=0.4,
            radius=7,
            kernel_size=25,
            top_hue=150,  # Change this value to adjust the color range
            low_hue=100,  # Change this value to adjust the color range
            gamma=1  # Adjust the gamma value for color distribution
        )
        heat_mask = None
        annotated_frame, heat_mask = heat_map_annotator.annotate(
            scene=working_image.copy(),
            detections=detections,
            heat_mask=heat_mask
        )

        # Apply decay to the annotated_frame
        current_time = time.time()
        decay_factor = 0.97  # Increase the decay_factor value
        mask = heat_mask > 0
        if mask.any():
            heat_mask *= decay_factor
            annotated_frame[mask] = cv2.addWeighted(
                annotated_frame[mask],
                heat_map_annotator.opacity,
                working_image[mask],
                1 - heat_map_annotator.opacity,
                0
            )

        # Update the working_image with the decayed heat_mask
        working_image[mask] = cv2.addWeighted(
            annotated_frame[mask],
            heat_map_annotator.opacity,
            working_image[mask],
            1 - heat_map_annotator.opacity,
            0
        )

        # Encode the decayed annotated_frame
        success, encoded_frame_heatmap = cv2.imencode('.jpg', annotated_frame)
    base64_encoded_annotated_frame = base64.b64encode(encoded_frame_heatmap).decode('utf-8')

Additional

I'm using the supervision library version 0.9.0.
The input video frames are 1280x720 resolution, and the frame rate is 24 FPS.
The lobby area is relatively small, and the number of people moving around at any given time is typically between 5 and 15.
I would greatly appreciate any suggestions or insights on how to improve the visibility and behavior of the heatmap color changes, especially when dealing with a narrow range of heat values. Any alternative approaches or techniques that could help achieve the desired result would also be very helpful.

Note: for this implementation color is constant (for me it's blue), it doesn't change at all even if the heat signature is high in that area

[SkalskiP]

Hi @vipinap98 👋🏻 Let me convert this issue into a discussion and place it in the Q&A section.