def spawn_sensors(world: carla.World, actor: carla.Actor) -> Dict[str, carla.Sensor]: sensors = {} blueprints = { "rgb": world.get_blueprint_library().find('sensor.camera.rgb'), "segmentation": world.get_blueprint_library().find( 'sensor.camera.semantic_segmentation'), "depth": world.get_blueprint_library().find('sensor.camera.depth') } fov = random.randint(60, 110) yaw = random.gauss(0, 45) sensor_transform = carla.Transform(carla.Location(0, 0, 3), carla.Rotation(0, yaw, 0)) for sensor_name, blueprint in blueprints.items(): blueprint.set_attribute("image_size_x", str(1920 / 2)) blueprint.set_attribute("image_size_y", str(1080 / 2)) blueprint.set_attribute("fov", str(fov)) blueprint.set_attribute( "sensor_tick", str(SENSOR_TICK)) # Get new data every x second sensor: carla.Sensor = world.spawn_actor(blueprint, sensor_transform, attach_to=actor) sensors[sensor_name] = sensor return sensors
def spawn_vehicles( world: carla.World, # pylint: disable=no-member num_vehicles: int, ) -> Sequence[carla.Vehicle]: # pylint: disable=no-member """Spawns `vehicles` randomly in spawn points. Args: world: The world object associated with the simulation. num_vehicles: The number of vehicles to spawn. Returns: The list of vehicles actors. """ # Blueprints library. bl = world.get_blueprint_library() # List of spawn points. spawn_points = world.get_map().get_spawn_points() # Output container actors = list() for _ in range(num_vehicles): # Fetch random blueprint. vehicle_bp = random.choice(bl.filter("vehicle.*")) # Attempt to spawn vehicle in random location. actor = world.try_spawn_actor(vehicle_bp, random.choice(spawn_points)) if actor is not None: # Enable autopilot. actor.set_autopilot(True) # Append actor to the list. actors.append(actor) logging.debug("Spawned {} other vehicles".format(len(actors))) return actors
def spawn_hero( world: carla.World, # pylint: disable=no-member spawn_point: carla.Transform, # pylint: disable=no-member vehicle_id: Optional[str] = None, ) -> carla.Vehicle: # pylint: disable=no-member """Spawns `hero` in `spawn_point`. Args: world: The world object associated with the simulation. spawn_point: The point to spawn the hero actor. vehicle_id: An (optional) valid id for the vehicle object. Returns: The actor (vehicle) object. """ # Blueprints library. bl = world.get_blueprint_library() if vehicle_id is not None: # Get the specific vehicle from the library. hero_bp = bl.find(vehicle_id) else: # Randomly choose a vehicle from the list. hero_bp = random.choice(bl.filter("vehicle.*")) # Rename the actor to `hero`. hero_bp.set_attribute("role_name", "hero") logging.debug("Spawns hero actor at {}".format( carla_xyz_to_ndarray(spawn_point.location))) hero = world.spawn_actor(hero_bp, spawn_point) return hero
def get_blueprints(world: carla.World, vehicles_filter: str = None, pedestrians_filter: str = None, safe=True): """Returns a list of blueprints for vehicles and pedestrians""" if vehicles_filter is None: vehicles_filter = 'vehicle.*' if pedestrians_filter is None: pedestrians_filter = 'walker.pedestrian.*' blueprint_lib = world.get_blueprint_library() vehicles_blueprints = blueprint_lib.filter(vehicles_filter) walkers_blueprints = blueprint_lib.filter(pedestrians_filter) if safe: vehicles_blueprints = filter( lambda b: (int(b.get_attribute('number_of_wheels')) == 4) and not (b.id.endswith('isetta') or b.id.endswith('carlacola') or b.id. endswith('cybertruck') or b.id.endswith('t2')), vehicles_blueprints) vehicles_blueprints = list(vehicles_blueprints) return vehicles_blueprints, walkers_blueprints
def random_blueprint(world: carla.World, actor_filter='vehicle.*', role_name='agent') -> carla.ActorBlueprint: """Retrieves a random blueprint. :param world: a carla.World instance. :param actor_filter: a string used to filter (select) blueprints. Default: 'vehicle.*' :param role_name: blueprint's role_name, Default: 'agent'. :return: a carla.ActorBlueprint instance. """ blueprints = world.get_blueprint_library().filter(actor_filter) blueprint: carla.ActorBlueprint = random.choice(blueprints) blueprint.set_attribute('role_name', role_name) if blueprint.has_attribute('color'): color = random.choice( blueprint.get_attribute('color').recommended_values) blueprint.set_attribute('color', color) if blueprint.has_attribute('driver_id'): driver_id = random.choice( blueprint.get_attribute('driver_id').recommended_values) blueprint.set_attribute('driver_id', driver_id) if blueprint.has_attribute('is_invincible'): blueprint.set_attribute('is_invincible', 'true') # set the max speed if blueprint.has_attribute('speed'): float(blueprint.get_attribute('speed').recommended_values[1]) float(blueprint.get_attribute('speed').recommended_values[2]) else: print("No recommended values for 'speed' attribute") return blueprint
def __init__(self, carla_world: carla.World, ego_vehicle: carla.Vehicle): # Params for images self.img_width = 1280 # in [px] self.img_height = 720 # in [px] self.fov_horizontal = 120 # in [deg] self.display_width = 640 # in [px] self.display_height = 360 # in [px] # Params for static camera calibration self.translation_x = 0.4 # in [m] from center of car self.translation_z = 1.5 # in [m] from bottom of car self.translation_y = 0.0 # in [m] from center of car self.pitch = 0.0 # in [deg] self.roll = 0.0 # in [deg] self.yaw = 0.0 # in [deg] # Images that are stored on disk per frame self.rgb_img: np.array = np.zeros((self.img_height, self.img_width, 3), dtype=np.uint8) self.depth_img: np.array = np.zeros((self.img_height, self.img_width, 3), dtype=np.uint8) self.semseg_img: np.array = np.zeros((self.img_height, self.img_width, 3), dtype=np.uint8) # Images that are displayed in pygame for visualization (note spectator img is just needed for visu) self.display_spectator_img: np.array = np.zeros((self.display_height, self.display_width, 3), dtype=np.uint8) self.display_rgb_img: np.array = np.zeros((self.display_height, self.display_width, 3), dtype=np.uint8) self.display_depth_img: np.array = np.zeros((self.display_height, self.display_width, 3), dtype=np.uint8) self.display_semseg_img: np.array = np.zeros((self.display_height, self.display_width, 3), dtype=np.uint8) # Create sensors blueprint_library: carla.BlueprintLibrary = carla_world.get_blueprint_library() cam_transform = carla.Transform( carla.Location(x=self.translation_x, z=self.translation_z, y=self.translation_y), carla.Rotation(pitch=self.pitch, yaw=self.yaw, roll=self.roll) ) # Attach dummy rgb sensor to follow the ego vehicle (only for visulization) spectator_bp = blueprint_library.find('sensor.camera.rgb') self._add_attr_to_blueprint(spectator_bp) spectator_transform = carla.Transform(carla.Location(x=-6, z=3)) self.spectator: carla.Actor = carla_world.spawn_actor(spectator_bp, spectator_transform, attach_to=ego_vehicle) self.spectator.listen(self._read_spectator_img) # Attach rgb cam sensors to ego vehicle cam_rgb_bp = blueprint_library.find('sensor.camera.rgb') self._add_attr_to_blueprint(cam_rgb_bp) self.cam_rgb: carla.Actor = carla_world.spawn_actor(cam_rgb_bp, cam_transform, attach_to=ego_vehicle) self.cam_rgb.listen(self._read_rgb_img) # Attach depth sensor to ego vehicle cam_depth_bp = blueprint_library.find("sensor.camera.depth") self._add_attr_to_blueprint(cam_depth_bp) self.cam_depth: carla.Actor = carla_world.spawn_actor(cam_depth_bp, cam_transform, attach_to=ego_vehicle) self.cam_depth.listen(self._read_depth_img) # Attach semseg sensor to ego vehicle cam_semseg_bp = blueprint_library.find("sensor.camera.semantic_segmentation") self._add_attr_to_blueprint(cam_semseg_bp) self.cam_semseg: carla.Actor = carla_world.spawn_actor(cam_semseg_bp, cam_transform, attach_to=ego_vehicle) self.cam_semseg.listen(self._read_semseg_img)
def __init__(self, world: carla.World, carla_vehicle: carla.Vehicle): self.has_collided = False def on_collision(e): self.has_collided = True blueprint_library = world.get_blueprint_library() blueprint = blueprint_library.find('sensor.other.collision') self._collision_sensor = world.spawn_actor( blueprint, carla_vehicle.get_transform(), attach_to=carla_vehicle) self._collision_sensor.listen(on_collision)
def prepare_ego_vehicle(world: carla.World) -> carla.Actor: car_blueprint = world.get_blueprint_library().find("vehicle.audi.a2") # This will allow external scripts like manual_control.py or no_rendering_mode.py # from the official CARLA examples to take control over the ego agent car_blueprint.set_attribute("role_name", "hero") # spawn points doesnt matter - scenario sets up position in reset ego_vehicle = world.spawn_actor( car_blueprint, carla.Transform(carla.Location(0, 0, 500), carla.Rotation())) assert ego_vehicle is not None, "Ego vehicle could not be spawned" # Setup any car sensors you like, collect observations and then use them as input to your model return ego_vehicle
def spawn_pedestrians( world: carla.World, # pylint: disable=no-member num_pedestrians: int, speeds: Sequence[float] = (1.0, 1.5, 2.0), ) -> Sequence[carla.Vehicle]: # pylint: disable=no-member """Spawns `pedestrians` in random locations. Args: world: The world object associated with the simulation. num_pedestrians: The number of pedestrians to spawn. speeds: The valid set of speeds for the pedestrians. Returns: The list of pedestrians actors. """ # Blueprints library. bl = world.get_blueprint_library() # Output container actors = list() for n in range(num_pedestrians): # Fetch random blueprint. pedestrian_bp = random.choice(bl.filter("walker.pedestrian.*")) # Make pedestrian invicible. pedestrian_bp.set_attribute("is_invincible", "true") while len(actors) != n: # Get random location. spawn_point = carla.Transform() # pylint: disable=no-member spawn_point.location = world.get_random_location_from_navigation() if spawn_point.location is None: continue # Attempt to spawn vehicle in random location. actor = world.try_spawn_actor(pedestrian_bp, spawn_point) player_control = carla.WalkerControl() player_control.speed = 3 pedestrian_heading = 90 player_rotation = carla.Rotation(0, pedestrian_heading, 0) player_control.direction = player_rotation.get_forward_vector() if actor is not None: actor.apply_control(player_control) actors.append(actor) logging.debug("Spawned {} pedestrians".format(len(actors))) return actors
def __init__(self, client: carla.Client, world: carla.World, safe_mode=True): self.client = client self.world = world self.spawn_points = self.world.get_map().get_spawn_points() self.blueprints = self.world.get_blueprint_library().filter( "vehicle.*") self.blueprintsWalkers = world.get_blueprint_library().filter( "walker.pedestrian.*") self.vehicles_list: List[int] = [] self.walkers_list = [] self.all_id = [] self.all_actors = [] self.safe_mode = safe_mode self._bad_colors = [ "255,255,255", "183,187,162", "237,237,237", "134,134,134", "243,243,243", "127,130,135", "109,109,109", "181,181,181", "140,140,140", "181,178,124", "171,255,0", "251,241,176", "158,149,129", "233,216,168", "233,216,168", "108,109,126", "193,193,193", "227,227,227", "151,150,125", "206,206,206", "255,222,218", "211,211,211", "191,191,191" ] if safe_mode else []
def get_blueprint(world: carla.World, actor_id: str) -> carla.ActorBlueprint: return world.get_blueprint_library().find(actor_id)