| import rclpy |
| from rclpy.node import Node |
| from sensor_msgs.msg import Image, Imu, PointCloud2 |
| import sensor_msgs_py.point_cloud2 as pc2 |
| from nav_msgs.msg import Odometry |
| from std_msgs.msg import String |
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib.gridspec import GridSpec |
| from mpl_toolkits.mplot3d import Axes3D |
| import matplotlib.patches as mpatches |
| import json |
| import cv2 |
| from cv_bridge import CvBridge |
| from scipy.spatial.transform import Rotation as R |
|
|
| class MultiSensorMonitor(Node): |
| def __init__(self): |
| super().__init__('multi_sensor_monitor') |
| self.bridge = CvBridge() |
| |
| self.label_colors = {} |
| self.class_name_to_color = { |
| 'unlabeled': [0, 0, 0] |
| } |
| |
| self.data = { |
| 'bev_rgb': None, 'bev_sem': None, |
| 'front_rgb': None, 'front_sem': None, 'front_depth': None, |
| 'bev_labels': {}, |
| 'front_labels': {}, |
| 'odom_x': [], 'odom_y': [], |
| 'imu_quat': [0.0, 0.0, 0.0, 1.0], |
| 'lidar_points': None |
| } |
|
|
| |
| self.create_subscription(Image, '/bev/rgb', self.cb_bev_rgb, 10) |
| self.create_subscription(Image, '/bev/semantic_segmentation', self.cb_bev_sem, 10) |
| self.create_subscription(String, '/bev/semantic_labels', self.cb_bev_labels, 10) |
| self.create_subscription(Image, '/camera_front/rgb', self.cb_front_rgb, 10) |
| self.create_subscription(Image, '/camera_front/semantic_segmentation', self.cb_front_sem, 10) |
| self.create_subscription(Image, '/camera_front/depth', self.cb_front_depth, 10) |
| self.create_subscription(String, '/camera_front/semantic_labels', self.cb_front_labels, 10) |
| self.create_subscription(Odometry, '/odom', self.cb_odom, 10) |
| self.create_subscription(Imu, '/imu', self.cb_imu, 10) |
| self.create_subscription(PointCloud2, '/lidar_front/point_cloud', self.cb_lidar, 10) |
|
|
| plt.ion() |
| |
| |
| self.fig = plt.figure(figsize=(18, 8), layout='constrained') |
| gs = GridSpec(2, 4, figure=self.fig) |
| |
| self.ax_bev_rgb = self.fig.add_subplot(gs[0, 0]) |
| self.ax_bev_sem = self.fig.add_subplot(gs[1, 0]) |
| self.ax_f_rgb = self.fig.add_subplot(gs[0, 1]) |
| self.ax_f_sem = self.fig.add_subplot(gs[1, 1]) |
| self.ax_f_depth = self.fig.add_subplot(gs[1, 2]) |
| self.ax_lidar = self.fig.add_subplot(gs[0, 2]) |
| self.ax_odom = self.fig.add_subplot(gs[0, 3]) |
| self.ax_imu = self.fig.add_subplot(gs[1, 3], projection='3d') |
| |
| self.cb_depth_bar = None |
| self.cb_lidar_bar = None |
|
|
| self.timer = self.create_timer(0.1, self.update_plot) |
|
|
| def get_color(self, uid): |
| if uid not in self.label_colors: |
| np.random.seed(uid) |
| self.label_colors[uid] = np.random.randint(0, 255, size=3).tolist() |
| return self.label_colors[uid] |
| |
| def get_color_by_name(self, class_name): |
| if class_name not in self.class_name_to_color: |
| seed = sum(ord(c) for c in class_name) |
| np.random.seed(seed) |
| self.class_name_to_color[class_name] = np.random.randint(0, 255, size=3).tolist() |
| return self.class_name_to_color[class_name] |
|
|
| def cb_lidar(self, msg): |
| points_gen = pc2.read_points(msg, field_names=("x", "y", "z"), skip_nans=True) |
| pts_list = [(p[0], p[1], p[2]) for p in points_gen] |
| if pts_list: |
| self.data['lidar_points'] = np.array(pts_list, dtype=np.float32) |
| else: |
| self.data['lidar_points'] = None |
|
|
| def cb_odom(self, msg): |
| self.data['odom_x'].append(msg.pose.pose.position.x) |
| self.data['odom_y'].append(msg.pose.pose.position.y) |
| if len(self.data['odom_x']) > 1000: |
| self.data['odom_x'].pop(0); self.data['odom_y'].pop(0) |
|
|
| def cb_imu(self, msg): |
| q = msg.orientation |
| self.data['imu_quat'] = [q.x, q.y, q.z, q.w] |
|
|
| def cb_bev_rgb(self, msg): self.data['bev_rgb'] = self.bridge.imgmsg_to_cv2(msg, "bgr8") |
| def cb_bev_sem(self, msg): self.data['bev_sem'] = self.bridge.imgmsg_to_cv2(msg, "32SC1") |
| def cb_front_rgb(self, msg): self.data['front_rgb'] = self.bridge.imgmsg_to_cv2(msg, "bgr8") |
| def cb_front_sem(self, msg): self.data['front_sem'] = self.bridge.imgmsg_to_cv2(msg, "32SC1") |
| |
| def cb_bev_labels(self, msg): |
| try: |
| raw_data = json.loads(msg.data) |
| self.data['bev_labels'] = {int(k): v['class'] for k, v in raw_data.items() if k.isdigit()} |
| except Exception as e: |
| pass |
|
|
| def cb_front_labels(self, msg): |
| try: |
| raw_data = json.loads(msg.data) |
| self.data['front_labels'] = {int(k): v['class'] for k, v in raw_data.items() if k.isdigit()} |
| except Exception as e: |
| pass |
|
|
| def colorize_semantic(self, sem_img, label_map): |
| if sem_img is None: return np.zeros((100, 100, 3), dtype=np.uint8) |
| h, w = sem_img.shape |
| color_img = np.zeros((h, w, 3), dtype=np.uint8) |
| unique_ids = np.unique(sem_img) |
| for uid in unique_ids: |
| if uid == 0: continue |
| class_name = label_map.get(uid, 'unknown') |
| color_img[sem_img == uid] = self.get_color_by_name(class_name) |
| return color_img |
|
|
| def cb_front_depth(self, msg): |
| depth_img = self.bridge.imgmsg_to_cv2(msg, "32FC1") |
| self.data['front_depth'] = np.clip(depth_img, 0.0, 10.0) |
|
|
| def update_plot(self): |
| for ax in [self.ax_bev_rgb, self.ax_bev_sem, self.ax_odom, self.ax_f_rgb, |
| self.ax_f_sem, self.ax_f_depth, self.ax_lidar]: |
| ax.clear() |
| self.ax_imu.cla() |
|
|
| |
| if self.data['bev_rgb'] is not None: |
| self.ax_bev_rgb.imshow(cv2.cvtColor(self.data['bev_rgb'], cv2.COLOR_BGR2RGB)) |
| self.ax_bev_rgb.set_xticks([]); self.ax_bev_rgb.set_yticks([]) |
| self.ax_bev_rgb.set_title("BEV RGB") |
| |
| if self.data['bev_sem'] is not None: |
| colored_bev = self.colorize_semantic(self.data['bev_sem'], self.data['bev_labels']) |
| self.ax_bev_sem.imshow(colored_bev) |
| self.ax_bev_sem.set_xticks([]); self.ax_bev_sem.set_yticks([]) |
| self.ax_bev_sem.set_title("BEV Semantic") |
|
|
| |
| if self.data['front_rgb'] is not None: |
| self.ax_f_rgb.imshow(cv2.cvtColor(self.data['front_rgb'], cv2.COLOR_BGR2RGB)) |
| self.ax_f_rgb.set_xticks([]); self.ax_f_rgb.set_yticks([]) |
| self.ax_f_rgb.set_title("Front RGB") |
| |
| if self.data['front_sem'] is not None: |
| colored_front = self.colorize_semantic(self.data['front_sem'], self.data['front_labels']) |
| self.ax_f_sem.imshow(colored_front) |
| self.ax_f_sem.set_xticks([]); self.ax_f_sem.set_yticks([]) |
| self.ax_f_sem.set_title("Front Semantic") |
|
|
| |
| legend_patches = [mpatches.Patch(color=np.array(col)/255.0, label=name) |
| for name, col in self.class_name_to_color.items() if name != 'unlabeled'] |
| if legend_patches: |
| |
| self.ax_f_sem.legend(handles=legend_patches, loc='center left', bbox_to_anchor=(1.02, 0.5), |
| fontsize='8', title="Semantic Classes") |
|
|
| |
| if self.data['front_depth'] is not None: |
| im_depth = self.ax_f_depth.imshow(self.data['front_depth'], cmap='magma', vmin=0, vmax=10) |
| self.ax_f_depth.set_xticks([]); self.ax_f_depth.set_yticks([]) |
| self.ax_f_depth.set_title("Front Depth") |
| |
| if self.cb_depth_bar is None: |
| self.cb_depth_bar = self.fig.colorbar(im_depth, ax=self.ax_f_depth, fraction=0.046, pad=0.04) |
| self.cb_depth_bar.set_label('Depth [m]') |
| else: |
| self.cb_depth_bar.update_normal(im_depth) |
|
|
| |
| if self.data['lidar_points'] is not None: |
| pts = self.data['lidar_points'] |
| scat = self.ax_lidar.scatter(pts[:, 0], pts[:, 1], s=1, c=pts[:, 2], cmap='viridis', vmin=-2, vmax=3) |
| self.ax_lidar.set_xlim([-1, 7]); self.ax_lidar.set_ylim([-7, 7]) |
| self.ax_lidar.set_title("Lidar Top-Down") |
| self.ax_lidar.set_xlabel('X [m]') |
| self.ax_lidar.set_ylabel('Y [m]') |
| self.ax_lidar.grid(True, linestyle=':', alpha=0.6) |
|
|
| if self.cb_lidar_bar is None: |
| self.cb_lidar_bar = self.fig.colorbar(scat, ax=self.ax_lidar, fraction=0.046, pad=0.04) |
| self.cb_lidar_bar.set_label('Elevation (Z) [m]') |
| else: |
| self.cb_lidar_bar.update_normal(scat) |
|
|
| |
| if self.data['odom_x']: |
| self.ax_odom.plot(self.data['odom_x'], self.data['odom_y'], 'b-', linewidth=1.5) |
| self.ax_odom.plot(self.data['odom_x'][-1], self.data['odom_y'][-1], 'ro', markersize=5) |
| self.ax_odom.set_title("Odom Path") |
| self.ax_odom.set_xbound(0, 20) |
| self.ax_odom.set_ybound(-1, 6) |
| self.ax_odom.set_xlabel('X [m]') |
| self.ax_odom.set_ylabel('Y [m]') |
| self.ax_odom.grid(True, linestyle=':', alpha=0.6) |
|
|
| |
| r = R.from_quat(self.data['imu_quat']) |
| labels = ['X', 'Y', 'Z'] |
| colors = ['r', 'g', 'b'] |
| |
| for i, (color, lbl) in enumerate(zip(colors, labels)): |
| vec = np.zeros(3); vec[i] = 1 |
| v_rot = r.apply(vec) |
| self.ax_imu.quiver(0, 0, 0, v_rot[0], v_rot[1], v_rot[2], color=color, arrow_length_ratio=0.15, linewidth=2) |
| self.ax_imu.text(v_rot[0]*1.2, v_rot[1]*1.2, v_rot[2]*1.2, lbl, color=color, fontweight='bold') |
| |
| self.ax_imu.set_xlim([-1, 1]); self.ax_imu.set_ylim([-1, 1]); self.ax_imu.set_zlim([-1, 1]) |
| self.ax_imu.set_title("IMU Orientation") |
| |
| |
| self.ax_imu.grid(True) |
| self.ax_imu.set_xticks([-1, 0, 1]) |
| self.ax_imu.set_yticks([-1, 0, 1]) |
| self.ax_imu.set_zticks([-1, 0, 1]) |
| |
| |
| self.ax_imu.xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) |
| self.ax_imu.yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) |
| self.ax_imu.zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0)) |
| |
| plt.draw() |
| plt.pause(0.001) |
|
|
| def main(args=None): |
| rclpy.init(args=args) |
| node = MultiSensorMonitor() |
| try: |
| rclpy.spin(node) |
| except KeyboardInterrupt: |
| pass |
| node.destroy_node() |
| rclpy.shutdown() |
|
|
| if __name__ == '__main__': |
| main() |
