| import os |
| import glob |
| import cv2 |
| import numpy as np |
| import yaml |
| import json |
| import rosbag2_py |
| from rclpy.serialization import deserialize_message |
| from rosidl_runtime_py.utilities import get_message |
| import sensor_msgs_py.point_cloud2 as pc2 |
|
|
| class BagDatasetExtractor: |
| def __init__(self, bag_path, output_dir, lidar_transform_path, camera_transform_path, start_frame_idx=0): |
| self.bag_path = bag_path |
| self.output_dir = output_dir |
| self.lidar_transform_path = lidar_transform_path |
| self.camera_transform_path = camera_transform_path |
| self.frame_idx = start_frame_idx |
| |
| self.prepare_folders() |
| |
| |
| self.reader = rosbag2_py.SequentialReader() |
| storage_options = rosbag2_py.StorageOptions(uri=self.bag_path, storage_id='sqlite3') |
| converter_options = rosbag2_py.ConverterOptions( |
| input_serialization_format='cdr', |
| output_serialization_format='cdr' |
| ) |
| self.reader.open(storage_options, converter_options) |
| |
| self.topic_types = {topic.name: topic.type for topic in self.reader.get_all_topics_and_types()} |
| self.transforms = self._load_transforms() |
|
|
| |
| ''' |
| $ ros2 topic echo --once /bev/semantic_labels |
| data: '{"0":{"class":"BACKGROUND"},"1":{"class":"UNLABELLED"},"2":{"class":"leaf"},"3":{"class":"branch"},"4":{"class":"weed"},"5":{"cl...' |
| --- |
| $ ros2 topic echo --once /bev/semantic_labels_bb |
| data: '{"0":{"class":"ground"},"1":{"class":"leaf"},"2":{"class":"branch"},"3":{"class":"weed"},"4":{"class":"obstacle"},"time_stamp":{...' |
| --- |
| |
| ''' |
| self.target_classes = {"ground": 0, "leaf": 1, "branch": 2, "weed": 3, "obstacle": 4} |
| self.semantic_mapping = {} |
| self.bb_mapping = {} |
|
|
| def _create_matrix_from_yaml(self, transform_data): |
| t = transform_data['transformation']['translation'] |
| q = transform_data['transformation']['rotation'] |
| |
| translation = np.array([t['x'], t['y'], t['z']]) |
| |
| x, y, z, w = q['x'], q['y'], q['z'], q['w'] |
|
|
| |
| norm = np.sqrt(x*x + y*y + z*z + w*w) |
| if norm == 0: |
| |
| x, y, z, w = 0, 0, 0, 1 |
| else: |
| x /= norm |
| y /= norm |
| z /= norm |
| w /= norm |
|
|
| |
| rotation_matrix = np.array([ |
| [1 - 2*y*y - 2*z*z, 2*x*y - 2*z*w, 2*x*z + 2*y*w], |
| [2*x*y + 2*z*w, 1 - 2*x*x - 2*z*z, 2*y*z - 2*x*w], |
| [2*x*z - 2*y*w, 2*y*z + 2*x*w, 1 - 2*x*x - 2*y*y] |
| ]) |
|
|
| |
| matrix = np.eye(4) |
| matrix[:3, :3] = rotation_matrix |
| matrix[:3, 3] = translation |
| |
| return matrix |
| |
| def _load_transforms(self): |
| transforms = {} |
| try: |
| with open(self.lidar_transform_path, 'r') as f: |
| lidar_transform_data = yaml.safe_load(f) |
| transforms['lidar_to_parent'] = self._create_matrix_from_yaml(lidar_transform_data) |
| with open(self.camera_transform_path, 'r') as f: |
| camera_transform_data = yaml.safe_load(f) |
| transforms['camera_to_parent'] = self._create_matrix_from_yaml(camera_transform_data) |
| except Exception as e: |
| print(f"Warning: Transform file issue: {e}") |
| return transforms |
|
|
| def prepare_folders(self): |
| for sub in ['rgb', 'depth', 'lidar', 'bev_label', 'extrinsics']: |
| os.makedirs(os.path.join(self.output_dir, sub), exist_ok=True) |
|
|
| def _parse_label_json(self, json_str): |
| """Extracts the mapping from Isaac Sim JSON string to our fixed IDs.""" |
| mapping = {} |
| try: |
| data = json.loads(json_str) |
| for key, val in data.items(): |
| if isinstance(val, dict) and "class" in val: |
| class_name = val["class"].lower() |
| if class_name in self.target_classes: |
| mapping[int(key)] = self.target_classes[class_name] |
| except json.JSONDecodeError: |
| print(f"Warning: Failed to parse JSON label string: {json_str}") |
| return mapping |
|
|
| def process_bev_logic(self, semantic_msg, bbox_msg): |
| height, width = semantic_msg.height, semantic_msg.width |
| semantic_raw = np.frombuffer(semantic_msg.data, dtype=np.int32).reshape((height, width)) |
| |
| |
| remapped_semantic = np.full_like(semantic_raw, 3, dtype=np.uint8) |
| for isaac_id, target_id in self.semantic_mapping.items(): |
| remapped_semantic[semantic_raw == isaac_id] = target_id |
| |
| |
| for detection in bbox_msg.detections: |
| if detection.results: |
| try: |
| isaac_class_id = int(detection.results[0].hypothesis.class_id) |
| |
| if self.bb_mapping.get(isaac_class_id) == 2: |
| center_x = int(detection.bbox.center.position.x) |
| center_y = int(detection.bbox.center.position.y) |
| cv2.circle(remapped_semantic, (center_x, center_y), radius=3, color=2, thickness=-1) |
| except Exception as e: |
| continue |
| |
| return remapped_semantic |
|
|
| def run(self): |
| print(f"Starting extraction for bag: {os.path.basename(self.bag_path)}") |
| sync_data = {} |
|
|
| |
| self.reader.set_filter(rosbag2_py.StorageFilter(topics=[ |
| '/camera_front/rgb', '/camera_front/depth', '/lidar_front/point_cloud', |
| '/bev/semantic_segmentation', '/bev/bbox_2d', |
| '/bev/semantic_labels', '/bev/semantic_labels_bb' |
| ])) |
|
|
| while self.reader.has_next(): |
| (topic, data, t_msg) = self.reader.read_next() |
| msg_type = get_message(self.topic_types[topic]) |
| msg = deserialize_message(data, msg_type) |
|
|
| |
| if topic == '/bev/semantic_labels': |
| self.semantic_mapping = self._parse_label_json(msg.data) |
| continue |
| elif topic == '/bev/semantic_labels_bb': |
| self.bb_mapping = self._parse_label_json(msg.data) |
| continue |
|
|
| ts = msg.header.stamp.sec * 1e9 + msg.header.stamp.nanosec if hasattr(msg, 'header') else t_msg |
| time_key = int(ts / 100_000_000) |
|
|
| if time_key not in sync_data: |
| sync_data[time_key] = {} |
| |
| sync_data[time_key][topic] = msg |
|
|
| |
| required = ['/camera_front/rgb', '/camera_front/depth', |
| '/lidar_front/point_cloud', '/bev/semantic_segmentation', '/bev/bbox_2d'] |
| |
| if all(topic in sync_data[time_key] for topic in required): |
| if not self.semantic_mapping or not self.bb_mapping: |
| |
| del sync_data[time_key] |
| continue |
| |
| self.save_sample(sync_data[time_key]) |
| del sync_data[time_key] |
| |
| return self.frame_idx |
|
|
| def save_sample(self, data): |
| prefix = f"{self.frame_idx:06d}" |
|
|
| if not self.transforms or 'lidar_to_parent' not in self.transforms: |
| return |
|
|
| lidar_matrix = self.transforms['lidar_to_parent'] |
| cam_matrix = self.transforms['camera_to_parent'] |
|
|
| np.save(f"{self.output_dir}/extrinsics/{prefix}_lidar_to_base.npy", lidar_matrix) |
| np.save(f"{self.output_dir}/extrinsics/{prefix}_cam_to_base.npy", cam_matrix) |
|
|
| rgb_img = np.frombuffer(data['/camera_front/rgb'].data, dtype=np.uint8).reshape((480, 640, 3)) |
| cv2.imwrite(f"{self.output_dir}/rgb/{prefix}.jpg", cv2.cvtColor(rgb_img, cv2.COLOR_RGB2BGR)) |
|
|
| depth_img = np.frombuffer(data['/camera_front/depth'].data, dtype=np.float32).reshape((480, 640)) |
| np.save(f"{self.output_dir}/depth/{prefix}.npy", depth_img) |
|
|
| points = pc2.read_points_numpy(data['/lidar_front/point_cloud'], field_names=("x", "y", "z")) |
| points_hom = np.hstack((points, np.ones((points.shape[0], 1)))) |
| points_transformed = (lidar_matrix @ points_hom.T).T[:, :3] |
| np.save(f"{self.output_dir}/lidar/{prefix}.npy", points_transformed) |
|
|
| processed_label = self.process_bev_logic(data['/bev/semantic_segmentation'], data['/bev/bbox_2d']) |
| cv2.imwrite(f"{self.output_dir}/bev_label/{prefix}.png", processed_label) |
|
|
| if self.frame_idx % 50 == 0: |
| print(f" Saved {self.frame_idx} samples...") |
| self.frame_idx += 1 |
|
|
| if __name__ == "__main__": |
| BAGS_DIR = "bags" |
| OUTPUT_DIR = "dataset/" |
| LIDAR_TRANSFORM_PATH = "lidar.yaml" |
| CAMERA_TRANSFORM_PATH = "camera.yaml" |
| |
| |
| bag_paths = sorted(glob.glob(os.path.join(BAGS_DIR, "*"))) |
| |
| if not bag_paths: |
| print(f"No bags found in {BAGS_DIR}") |
| |
| current_frame_idx = 0 |
| for bag_path in bag_paths: |
| extractor = BagDatasetExtractor( |
| bag_path=bag_path, |
| output_dir=OUTPUT_DIR, |
| lidar_transform_path=LIDAR_TRANSFORM_PATH, |
| camera_transform_path=CAMERA_TRANSFORM_PATH, |
| start_frame_idx=current_frame_idx |
| ) |
| current_frame_idx = extractor.run() |
| |
| print(f"Finished extracting! Total frames processed: {current_frame_idx}") |
