Upload 2 files

utils/bag_extractor.py

@@ -0,0 +1,238 @@
+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()
+        
+        # ROS 2 Bag Reader Setup
+        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()
+
+        # Dynamic Mappings
+        '''
+        11225069610@A70i:~/Desktop/BEV_EDL/data/bags$ 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...'
+            ---
+            11225069610@A70i:~/Desktop/BEV_EDL/data/bags$ 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']
+
+        # Normalize quaternion
+        norm = np.sqrt(x*x + y*y + z*z + w*w)
+        if norm == 0:
+            # Handle zero-norm quaternion (invalid rotation)
+            x, y, z, w = 0, 0, 0, 1
+        else:
+            x /= norm
+            y /= norm
+            z /= norm
+            w /= norm
+
+        # Rotation matrix from quaternion
+        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]
+        ])
+
+        # Create 4x4 homogeneous matrix
+        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))
+        
+        # 1. Remap Semantic Image
+        remapped_semantic = np.full_like(semantic_raw, 3, dtype=np.uint8) # Default 3 (Other/Background)
+        for isaac_id, target_id in self.semantic_mapping.items():
+            remapped_semantic[semantic_raw == isaac_id] = target_id
+            
+        # 2. Add bounding box centers for branches
+        for detection in bbox_msg.detections:
+            if detection.results:
+                try:
+                    isaac_class_id = int(detection.results[0].hypothesis.class_id)
+                    # Use the BB mapping specifically for the bounding boxes
+                    if self.bb_mapping.get(isaac_class_id) == 2: # 2 is Branch
+                        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 = {}
+
+        # Added the label topics to the filter
+        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)
+
+            # Update Mappings dynamically if we see the label topics
+            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
+
+            # Only save the sample if we have all sensor data AND we have successfully captured our label mappings
+            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:
+                    # Skip until we receive the label definitions
+                    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 = "/home/11225069610/Desktop/BEV_EDL/data/bags" 
+    OUTPUT_DIR = "/home/11225069610/Desktop/bag_extract/"
+    LIDAR_TRANSFORM_PATH = "/home/11225069610/Desktop/BEV_EDL/data/lidar.yaml"
+    CAMERA_TRANSFORM_PATH = "/home/11225069610/Desktop/BEV_EDL/data/camera.yaml"
+    
+    # Find all bags in the directory
+    bag_paths = sorted(glob.glob(os.path.join(BAGS_DIR, "*")))
+    
+    if not bag_paths:
+        print(f"No bags found in {BAGS_DIR}")
+
+    bag_paths = ["/home/11225069610/Desktop/rosbag2_2026_03_27-16_05_37"]
+    
+    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}")

utils/scene_generator.py

@@ -0,0 +1,296 @@
+
+import omni
+import random
+import numpy as np
+from pxr import Usd, UsdGeom, Gf, Sdf, UsdShade
+from scipy.spatial.transform import Rotation
+
+# --- Asset and Scene Configuration ---
+
+CROP_ASSETS = {
+    "soybean": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
+    "sorghum": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
+    "cotton": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
+    "corn": ["_1", "_2", "_3", "_4", "_5", "_6", "_61", "_62", "_7", "_71", "_72", "_8", "_81", "_9", "_91", "_92"],
+    "cane": ["_1", "_2"]
+}
+
+CROP_AGES = {
+    "y": ["_1", "_2"],
+    "y-m": ["_3", "_4", "_5"],
+    "m-l": ["_5", "_6", "_7"],
+    "l": ["_8", "_9"]
+}
+
+ROW_SPACING = {
+    "corn": 0.45,
+    "soybean": 0.45,
+    "sorghum": 0.45,
+    "cotton": 0.9,
+    "cane": 1.0
+}
+
+WEED_ASSETS = [
+    "/World/base/weed/broadleaf_1",
+    "/World/base/weed/broadleaf_2",
+    "/World/base/weed/grass_1",
+    "/World/base/weed/grass_2"
+]
+
+OBSTACLE_ASSETS = [
+    "/World/ood/cones/c1",
+    "/World/ood/cones/c2",
+    "/World/ood/cones/c3",
+    "/World/ood/cones/c4",
+    "/World/ood/female_adult_police_01_new",
+    "/World/ood/male_adult_construction_01_new",
+    # "/World/ood/Tractor"
+]
+
+# Weed
+VOLUME_MAPPING = {
+    "none": 0,
+    "some": 50,  # Number of assets to spawn
+    "lot": 500
+}
+
+OBSTACLE_VOLUME_MAPPING = {
+    "none": 0,
+    "some": 5,
+    "lot": 15
+}
+
+TIME_OF_DAY_MAPPING = {
+    "early": 85,
+    "noon": 0,
+    "late": -75
+}
+
+# 
+GROUND_MATERIALS = [
+        "/FlatGrid/Looks/Dirt",
+        "/FlatGrid/Looks/Mulch_Brown",
+        "/FlatGrid/Looks/Mulch_Dry"
+]
+
+# --- Helper Functions ---
+
+def change_ground_material(stage):
+    """Changes the ground material using the MaterialBindingAPI."""
+    ground_path = "/FlatGrid/Environment"
+    ground_prim = stage.GetPrimAtPath(ground_path)
+    
+    if not ground_prim:
+        print(f"Ground prim not found at {ground_path}.")
+        return
+
+    material_path = random.choice(GROUND_MATERIALS)
+    material_prim = stage.GetPrimAtPath(material_path)
+    
+    if not material_prim:
+        print(f"Material prim not found at {material_path}.")
+        return
+
+    # Ensure the target prim is actually a Material
+    material = UsdShade.Material(material_prim)
+    if not material:
+        print(f"Prim at {material_path} is not a valid UsdShadeMaterial.")
+        return
+
+    # Apply the MaterialBindingAPI to the ground prim
+    binding_api = UsdShade.MaterialBindingAPI.Apply(ground_prim)
+    
+    # Bind the material. 
+    # UsdShade.Tokens.strongerThanDescendants ensures this material 
+    # overrides any materials assigned to child prims.
+    binding_api.Bind(material, bindingStrength=UsdShade.Tokens.strongerThanDescendants)
+
+    print(f"Successfully bound {ground_path} to {material_path}")
+
+
+def set_time_of_day(stage, time_of_day):
+    """Sets the absolute time of day by finding or creating the rotation op."""
+    sun_path = "/World/CumulusLight/AxisNorth/AxisLatitude/AxisSHA"
+    sun_prim = stage.GetPrimAtPath(sun_path)
+    
+    if not sun_prim:
+        print(f"Warning: Sun prim not found at {sun_path}.")
+        return
+
+    angle = TIME_OF_DAY_MAPPING.get(time_of_day, 180)
+    xform = UsdGeom.Xformable(sun_prim)
+    
+    # 1. Look for an existing RotateX operation in the stack
+    rotate_op = None
+    for op in xform.GetOrderedXformOps():
+        if op.GetOpType() == UsdGeom.XformOp.TypeRotateX:
+            rotate_op = op
+            break
+    
+    # 2. If it exists, set the absolute value. If not, create it.
+    if rotate_op:
+        rotate_op.Set(float(angle))
+    else:
+        # This adds the op to the stack and sets the initial absolute value
+        xform.AddRotateXOp(precision=UsdGeom.XformOp.PrecisionFloat).Set(float(angle))
+
+def set_robust_transform(prim, translation=None, rotation_euler=None, scale=None):
+    """
+    Robustly updates or adds transform operations to a prim.
+    Handles existing Ops, different precisions, and Quaternion vs Euler rotations.
+    """
+    xform = UsdGeom.Xformable(prim)
+    # We use this to track which ops we've updated to avoid duplicates
+    found_ops = {"translate": None, "rotate": None, "scale": None}
+    
+    for op in xform.GetOrderedXformOps():
+        op_type = op.GetOpType()
+        if op_type in [UsdGeom.XformOp.TypeTranslate]:
+            found_ops["translate"] = op
+        elif op_type in [UsdGeom.XformOp.TypeRotateXYZ, UsdGeom.XformOp.TypeOrient]:
+            found_ops["rotate"] = op
+        elif op_type in [UsdGeom.XformOp.TypeScale]:
+            found_ops["scale"] = op
+
+    # --- Handle Translation ---
+    if translation is not None:
+        if found_ops["translate"]:
+            found_ops["translate"].Set(translation)
+        else:
+            xform.AddTranslateOp().Set(translation)
+
+    # --- Handle Rotation (Euler Z to XYZ or Quat) ---
+    if rotation_euler is not None:
+        z_deg = rotation_euler[2] # Assuming we mostly care about Z for plants
+        if found_ops["rotate"]:
+            op = found_ops["rotate"]
+            attr_type = op.GetAttr().GetTypeName()
+            
+            if attr_type in (Sdf.ValueTypeNames.Quatf, Sdf.ValueTypeNames.Quatd):
+                # Convert Euler to Quat
+                r = Rotation.from_euler('z', z_deg, degrees=True)
+                q = r.as_quat() # x, y, z, w
+                quat_val = Gf.Quatd(q[3], q[0], q[1], q[2]) if attr_type == Sdf.ValueTypeNames.Quatd else Gf.Quatf(q[3], q[0], q[1], q[2])
+                op.Set(quat_val)
+            else:
+                # Standard Euler (Vec3f or Vec3d)
+                current_rot = op.Get() or Gf.Vec3f(0)
+                op.Set(Gf.Vec3f(current_rot[0], current_rot[1], z_deg))
+        else:
+            xform.AddRotateXYZOp().Set(Gf.Vec3f(0, 0, z_deg))
+
+    # --- Handle Scale ---
+    if scale is not None:
+        if found_ops["scale"]:
+            found_ops["scale"].Set(scale)
+        else:
+            xform.AddScaleOp().Set(scale)
+
+def scatter_assets(stage, asset_paths, num_assets, area_min, area_max, root_path):
+    if num_assets == 0: return
+    stage.DefinePrim(root_path, "Xform")
+    
+    for i in range(num_assets):
+        asset_path = random.choice(asset_paths)
+        new_path = f"{root_path}/item_{i}"
+        omni.usd.duplicate_prim(stage, asset_path, new_path)
+        
+        prim = stage.GetPrimAtPath(new_path)
+        pos = Gf.Vec3f(random.uniform(area_min[0], area_max[0]), 
+                       random.uniform(area_min[1], area_max[1]), 0)
+        rot = Gf.Vec3f(0, 0, random.uniform(0, 360))
+        
+        set_robust_transform(prim, translation=pos, rotation_euler=rot, scale=Gf.Vec3f(1.0))
+
+def get_crop_paths (crop_type, crop_age):
+    """Get valid prim paths for the selected crop type and age."""
+    base_path = f"/World/base/{crop_type}"
+    age_suffixes = CROP_AGES.get(crop_age, [])
+    available_suffixes = CROP_ASSETS.get(crop_type, [])
+    valid_suffixes = [s for s in age_suffixes if s in available_suffixes]
+    if not valid_suffixes:
+        raise ValueError(f"No assets found for crop {crop_type} with age {crop_age}'.")
+    return [f"{base_path}/{suffix}" for suffix in valid_suffixes]
+
+def generate_scene(config):
+    stage = omni.usd.get_context().get_stage()
+    # ... [Config parsing logic] ...
+
+    # --- Field Generation ---
+    root_crop_path = Sdf.Path(f"/root/{config['crop_type']}_{config['crop_age']}_field")
+    if stage.GetPrimAtPath(root_crop_path): stage.RemovePrim(root_crop_path)
+    stage.DefinePrim(root_crop_path, "Xform")
+
+    curve_effect = np.sin(np.linspace(0, 6 * np.pi, config["num_plants_in_row"])) * 0.35 if config["curve"] else np.zeros(config["num_plants_in_row"])
+
+    print(f"Generating {config['num_rows']} rows with {config['num_plants_in_row']} plants each (Curve: {config['curve']})")
+
+    for i in range(config["num_rows"]):
+        for j in range(config["num_plants_in_row"]):
+            if random.random() < 0.1: continue
+
+            new_prim_path = f"{root_crop_path}/row_{i}_plant_{j}"
+            omni.usd.duplicate_prim(stage, random.choice(get_crop_paths(config["crop_type"], config["crop_age"])), new_prim_path)
+            
+            prim = stage.GetPrimAtPath(new_prim_path)
+            
+            # Position logic
+            offset = random.uniform(-0.02, 0.02)
+            x_pos = i * ROW_SPACING.get(config["crop_type"], 0.45) + offset + curve_effect[j]
+            y_pos = j * 0.1 + offset
+            
+            # Scale logic
+            s = 1.0 + random.uniform(-0.05, 0.05)
+            
+            set_robust_transform(
+                prim, 
+                translation=Gf.Vec3f(x_pos, y_pos, 0), 
+                rotation_euler=Gf.Vec3f(0, 0, random.uniform(0, 360)),
+                scale=Gf.Vec3f(s, s, s)
+            )
+
+    # Scatter Weeds/Obstacles
+    field_w = config["num_rows"] * ROW_SPACING.get(config["crop_type"], 0.45)
+    field_l = config["num_plants_in_row"] * 0.1
+
+    print(f"Scattering weeds and obstacles (Weeds: {config['weed_volume']}, Obstacles: {config['obstacle_volume']})")
+    scatter_assets(stage, WEED_ASSETS, VOLUME_MAPPING[config["weed_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Weeds"))
+    print(f"Scattering obstacles (Volume: {config['obstacle_volume']})")
+    scatter_assets(stage, OBSTACLE_ASSETS, OBSTACLE_VOLUME_MAPPING[config["obstacle_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Obstacles"))
+    # print(f"Setting time of day to {config['time_of_day']}")
+    # set_time_of_day(stage, config["time_of_day"])
+    # print("Changing ground material")
+    # change_ground_material(stage)
+    print("Scene generation complete!")
+
+
+# --- USER CONFIGURATION ---
+# Modify the values in this dictionary to change the generated scene.
+CONFIG = {
+    "crop_type": "cane",           # Options: "soybean", "sorghum", "cotton", "corn"
+    "crop_age": "y",             # Options: "y", "y-m", "m-l", "l"
+    "curve": False,                 # Options: True or False
+    "num_plants_in_row": 250,        # Number of plants in each row
+    "num_rows": 20,                 # Number of rows in the field
+    "weed_volume": "none",         # Options: "none", "some", "lot"
+    "obstacle_volume": "none",     # Options: "none", "some", "lot"
+    "time_of_day": "noon"          # Options: "early", "noon", "late"
+}
+# --- END USER CONFIGURATION ---
+
+# Execute the scene generation
+generate_scene(CONFIG)
+
+# for crop_type in ["soybean", "sorghum", "cotton", "corn"]:
+#     for crop_age in ["y", "y-m", "m-l", "l"]:
+#         CONFIG = {
+#             "crop_type": crop_type,
+#             "crop_age": crop_age,
+#             "curve": False,
+#             "num_plants_in_row": 250,
+#             "num_rows": 20,
+#             "weed_volume": "some",
+#             "obstacle_volume": "some",
+#             "time_of_day": "noon"
+#         }
+#         generate_scene(CONFIG)