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