demo/utils.py

import numpy as np

def get_depth_map(depth_map_raw: np.ndarray) -> np.ndarray:
    """
    Converts a raw RGB-encoded depth map to actual one channel depth map.

    Parameters:
        depth_map_raw (np.ndarray): The raw RGB depth map where each pixel's RGB values encode depth information.
                                    The shape should be (height, width, 3).

    Returns:
        np.ndarray: The converted depth map where each pixel value represents the depth at that point in [0, 1000] meters.
                    The shape of the returned array is the same as the input but with only one channel.

    Description:
        The depth map camera captures a scene by encoding the distance of each pixel to the camera (also known as the depth buffer or z-buffer) into a 24-bit floating point precision image, codified across the RGB color space channels in the order of R --> G -> B .

        R	        G	        B	        int24	
        00000000	00000000	00000000	0	        min (near)
        11111111	11111111	11111111	16777215	max (far)

        The depth map is calculated by converting the RGB values to a single floating-point number using the formula:
        depth = (R + G * 256 + B * 256^2) / (256^3 - 1) * 1000
        Here R, G, B are the red, green, and blue channel values respectively, and the formula maps these to a range from 0 to 1000.

        For more details, please refer to: https://carla.readthedocs.io/en/latest/ref_sensors/#depth-camera
    """
    R = depth_map_raw[..., 0].astype(np.float32)
    G = depth_map_raw[..., 1].astype(np.float32)
    B = depth_map_raw[..., 2].astype(np.float32)
    depth_map = (R + G * 256 + B * 256 * 256) / (256 * 256 * 256 - 1) * 1000
    return depth_map


def get_segmentation_map(segmentation_map_raw: np.ndarray, colorize=False) -> np.ndarray:
    """
    Extracts a segmentation map from a raw color segmentation image. Depending on the 'colorize' flag,
    this function either returns a single-channel map or a colorized segmentation map where each label
    is mapped to a specific RGB color defined by the label_colors dictionary.

    Parameters:
        segmentation_map_raw (np.ndarray): The raw color segmentation image, with the shape (height, width, 3).
                                           Typically, the first channel (R) is used to represent segmentation information.
        colorize (bool): If True, returns a colorized segmentation map. If False, returns the original
                         segmentation map's R channel as a float32 array.

    Returns:
        np.ndarray: If colorize is False, returns the extracted single-channel segmentation map,
                    where values are floating-point, with the shape (height, width). If colorize is True,
                    returns a 3-channel RGB image where each segmentation label is mapped to a predefined color.

    Description:
        The semantic segmentation camera classifies every object in the view by displaying it in a different color
        according to the object class. For example, pedestrians appear in a different color than vehicles.
        It provides an image with the tag information encoded in the red channel. A pixel with a red value of x
        displays an object with tag x. When 'colorize' is True, each pixel's label is converted to a specific color
        based on a predefined dictionary mapping labels to colors.

        For more details, please refer to: https://carla.readthedocs.io/en/latest/ref_sensors/#semantic-segmentation-camera
    """
    if colorize:
        label_colors = {
            0: (0, 0, 0),
            1: (128, 64, 128),
            2: (244, 35, 232),
            3: (70, 70, 70),
            4: (102, 102, 156),
            5: (190, 153, 153),
            6: (153, 153, 153),
            7: (250, 170, 30),
            8: (220, 220, 0),
            9: (107, 142, 35),
            10: (152, 251, 152),
            11: (70, 130, 180),
            12: (220, 20, 60),
            13: (255, 0, 0),
            14: (0, 0, 142),
            15: (0, 0, 70),
            16: (0, 60, 100),
            17: (0, 60, 100),
            18: (0, 0, 230),
            19: (119, 11, 32),
            20: (110, 190, 160),
            21: (170, 120, 50),
            22: (55, 90, 80),
            23: (45, 60, 150),
            24: (157, 234, 50),
            25: (81, 0, 81),
            26: (150, 100, 100),
            27: (230, 150, 140),
            28: (180, 165, 180)
        }
        
        height, width = segmentation_map_raw.shape[:2]
        rgb_image = np.zeros((height, width, 3), dtype=np.uint8)
        
        for label, color in label_colors.items():
            rgb_image[segmentation_map_raw[..., 0] == label] = color

        return rgb_image
    else:
        return segmentation_map_raw[..., 0].astype(np.float32)