def _load_and_wait_for_world(self, args, town, ego_vehicles=None): """ Load a new CARLA world and provide data to CarlaDataProvider """ self.world = self.client.load_world(town) settings = self.world.get_settings() settings.fixed_delta_seconds = 1.0 / self.frame_rate settings.synchronous_mode = True self.world.apply_settings(settings) self.world.reset_all_traffic_lights() CarlaDataProvider.set_client(self.client) CarlaDataProvider.set_world(self.world) CarlaDataProvider.set_traffic_manager_port(args.traffic_manager_port) self.traffic_manager.set_synchronous_mode(True) self.traffic_manager.set_random_device_seed(args.traffic_manager_seed) self.traffic_manager.set_hybrid_physics_mode(True) # Wait for the world to be ready if CarlaDataProvider.is_sync_mode(): self.world.tick() else: self.world.wait_for_tick() if CarlaDataProvider.get_map().name != town: raise Exception("The CARLA server uses the wrong map!" "This scenario requires to use map {}".format(town))
def __init__(self, name, ego_vehicles, config, world, debug_mode=False, terminate_on_failure=False, criteria_enable=False): """ Setup all relevant parameters and create scenario and instantiate scenario manager """ self.other_actors = [] if not self.timeout: # pylint: disable=access-member-before-definition self.timeout = 60 # If no timeout was provided, set it to 60 seconds self.criteria_list = [] # List of evaluation criteria self.scenario = None self.world = world self.ego_vehicles = ego_vehicles self.name = name self.config = config self.terminate_on_failure = terminate_on_failure self._initialize_environment(world) # Initializing adversarial actors self._initialize_actors(config) if CarlaDataProvider.is_sync_mode(): world.tick() else: world.wait_for_tick() # Setup scenario if debug_mode: py_trees.logging.level = py_trees.logging.Level.DEBUG behavior = self._create_behavior() criteria = None if criteria_enable: criteria = self._create_test_criteria() # Add a trigger condition for the behavior to ensure the behavior is only activated, when it is relevant behavior_seq = py_trees.composites.Sequence() trigger_behavior = self._setup_scenario_trigger(config) if trigger_behavior: behavior_seq.add_child(trigger_behavior) if behavior is not None: behavior_seq.add_child(behavior) behavior_seq.name = behavior.name end_behavior = self._setup_scenario_end(config) if end_behavior: behavior_seq.add_child(end_behavior) self.scenario = Scenario(behavior_seq, criteria, self.name, self.timeout, self.terminate_on_failure)
def _build_scenario_instances(self, world, ego_vehicle, scenario_definitions, scenarios_per_tick=5, timeout=300, debug_mode=False): """ Based on the parsed route and possible scenarios, build all the scenario classes. """ scenario_instance_vec = [] if debug_mode: for scenario in scenario_definitions: loc = carla.Location(scenario['trigger_position']['x'], scenario['trigger_position']['y'], scenario['trigger_position']['z']) + carla.Location(z=2.0) world.debug.draw_point(loc, size=0.3, color=carla.Color(255, 0, 0), life_time=100000) world.debug.draw_string(loc, str(scenario['name']), draw_shadow=False, color=carla.Color(0, 0, 255), life_time=100000, persistent_lines=True) for scenario_number, definition in enumerate(scenario_definitions): # Get the class possibilities for this scenario number scenario_class = NUMBER_CLASS_TRANSLATION[definition['name']] # Create the other actors that are going to appear if definition['other_actors'] is not None: list_of_actor_conf_instances = self._get_actors_instances(definition['other_actors']) else: list_of_actor_conf_instances = [] # Create an actor configuration for the ego-vehicle trigger position egoactor_trigger_position = convert_json_to_transform(definition['trigger_position']) scenario_configuration = ScenarioConfiguration() scenario_configuration.other_actors = list_of_actor_conf_instances scenario_configuration.trigger_points = [egoactor_trigger_position] scenario_configuration.subtype = definition['scenario_type'] scenario_configuration.ego_vehicles = [ActorConfigurationData('vehicle.lincoln.mkz_2017', ego_vehicle.get_transform(), 'hero')] route_var_name = "ScenarioRouteNumber{}".format(scenario_number) scenario_configuration.route_var_name = route_var_name try: scenario_instance = scenario_class(world, [ego_vehicle], scenario_configuration, criteria_enable=False, timeout=timeout) # Do a tick every once in a while to avoid spawning everything at the same time if scenario_number % scenarios_per_tick == 0: if CarlaDataProvider.is_sync_mode(): world.tick() else: world.wait_for_tick() scenario_number += 1 except Exception as e: # pylint: disable=broad-except if debug_mode: traceback.print_exc() print("Skipping scenario '{}' due to setup error: {}".format(definition['name'], e)) continue scenario_instance_vec.append(scenario_instance) return scenario_instance_vec
def _load_and_wait_for_world(self, town, ego_vehicles=None): """ Load a new CARLA world and provide data to CarlaDataProvider """ if self._args.reloadWorld: self.world = self.client.load_world(town) else: # if the world should not be reloaded, wait at least until all ego vehicles are ready ego_vehicle_found = False if self._args.waitForEgo: while not ego_vehicle_found and not self._shutdown_requested: vehicles = self.client.get_world().get_actors().filter( 'vehicle.*') for ego_vehicle in ego_vehicles: ego_vehicle_found = False for vehicle in vehicles: if vehicle.attributes[ 'role_name'] == ego_vehicle.rolename: ego_vehicle_found = True break if not ego_vehicle_found: print("Not all ego vehicles ready. Waiting ... ") time.sleep(1) break self.world = self.client.get_world() if self._args.sync: settings = self.world.get_settings() settings.synchronous_mode = True settings.fixed_delta_seconds = 1.0 / self.frame_rate self.world.apply_settings(settings) self.traffic_manager.set_synchronous_mode(True) self.traffic_manager.set_random_device_seed( int(self._args.trafficManagerSeed)) CarlaDataProvider.set_client(self.client) CarlaDataProvider.set_world(self.world) CarlaDataProvider.set_traffic_manager_port( int(self._args.trafficManagerPort)) # Wait for the world to be ready if CarlaDataProvider.is_sync_mode(): self.world.tick() else: self.world.wait_for_tick() if CarlaDataProvider.get_map( ).name != town and CarlaDataProvider.get_map().name != "OpenDriveMap": print("The CARLA server uses the wrong map: {}".format( CarlaDataProvider.get_map().name)) print("This scenario requires to use map: {}".format(town)) return False return True
def __init__(self, name, ego_vehicles, config, world, debug_mode=False, terminate_on_failure=False, criteria_enable=False): """ Setup all relevant parameters and create scenario and instantiate scenario manager """ self.other_actors = [] if not self.timeout: # pylint: disable=access-member-before-definition self.timeout = 60 # If no timeout was provided, set it to 60 seconds self.category = None # Scenario category, e.g. control_loss, follow_leading_vehicle, ... self.criteria_list = [] # List of evaluation criteria self.scenario = None # Check if the CARLA server uses the correct map self._town = config.town self._check_town(world) self.ego_vehicles = ego_vehicles self.name = name self.terminate_on_failure = terminate_on_failure # Initializing adversarial actors self._initialize_actors(config) if not CarlaDataProvider.is_sync_mode(): world.wait_for_tick() else: world.tick() # Setup scenario if debug_mode: py_trees.logging.level = py_trees.logging.Level.DEBUG behavior = self._create_behavior() criteria = None if criteria_enable: criteria = self._create_test_criteria() # Add a trigger condition for the behavior to ensure the behavior is only activated, when it is relevant behavior_seq = py_trees.composites.Sequence() trigger_behavior = self._setup_scenario_trigger(config) if trigger_behavior: behavior_seq.add_child(trigger_behavior) behavior_seq.add_child(behavior) self.scenario = Scenario(behavior_seq, criteria, self.name, self.timeout, self.terminate_on_failure)
def _prepare_ego_vehicles(self, ego_vehicles): """ Spawn or update the ego vehicles """ if not self._args.waitForEgo: for vehicle in ego_vehicles: self.ego_vehicles.append( CarlaDataProvider.request_new_actor( vehicle.model, vehicle.transform, vehicle.rolename, color=vehicle.color, actor_category=vehicle.category)) else: ego_vehicle_missing = True while ego_vehicle_missing: self.ego_vehicles = [] ego_vehicle_missing = False for ego_vehicle in ego_vehicles: ego_vehicle_found = False carla_vehicles = CarlaDataProvider.get_world().get_actors( ).filter('vehicle.*') for carla_vehicle in carla_vehicles: if carla_vehicle.attributes[ 'role_name'] == ego_vehicle.rolename: ego_vehicle_found = True self.ego_vehicles.append(carla_vehicle) break if not ego_vehicle_found: ego_vehicle_missing = True break for i, _ in enumerate(self.ego_vehicles): self.ego_vehicles[i].set_transform(ego_vehicles[i].transform) CarlaDataProvider.register_actor(self.ego_vehicles[i]) # self.traffic_manager.vehicle_percentage_speed_difference(-70) # sync state if CarlaDataProvider.is_sync_mode(): self.world.tick() else: self.world.wait_for_tick()
world = client.load_world(city_name) traffic_manager = client.get_trafficmanager(int(trafficManagerPort)) settings = world.get_settings() settings.synchronous_mode = True settings.fixed_delta_seconds = 1.0 / frame_rate world.apply_settings(settings) traffic_manager.set_synchronous_mode(True) traffic_manager.set_random_device_seed(int(trafficManagerSeed)) CarlaDataProvider.set_client(client) CarlaDataProvider.set_world(world) CarlaDataProvider.set_traffic_manager_port(int(trafficManagerPort)) if CarlaDataProvider.is_sync_mode(): world.tick() else: world.wait_for_tick() # generate ego vehicle blueprint_library = world.get_blueprint_library() bp = random.choice(blueprint_library.filter('vehicle')) if bp.has_attribute('color'): color = random.choice(bp.get_attribute('color').recommended_values) bp.set_attribute('color', color) transform = random.choice(world.get_map().get_spawn_points()) vehicle = world.spawn_actor(bp, transform) actor_list.append(vehicle)
def _set_carla_town(self): """ Extract the CARLA town (level) from the RoadNetwork information from OpenSCENARIO Note: The specification allows multiple Logics elements within the RoadNetwork element. Hence, there can be multiple towns specified. We just use the _last_ one. """ for logic in self.xml_tree.find("RoadNetwork").findall("LogicFile"): self.town = logic.attrib.get('filepath', None) if self.town is not None and ".xodr" in self.town: if not os.path.isabs(self.town): self.town = os.path.dirname(os.path.abspath(self.filename)) + "/" + self.town if not os.path.exists(self.town): raise AttributeError("The provided RoadNetwork '{}' does not exist".format(self.town)) # workaround for relative positions during init world = self.client.get_world() wmap = None if world: world.get_settings() wmap = world.get_map() if world is None or (wmap is not None and wmap.name.split('/')[-1] != self.town): if ".xodr" in self.town: with open(self.town, 'r', encoding='utf-8') as od_file: data = od_file.read() index = data.find('<OpenDRIVE>') data = data[index:] old_map = "" if wmap is not None: old_map = wmap.to_opendrive() index = old_map.find('<OpenDRIVE>') old_map = old_map[index:] if data != old_map: self.logger.warning(" Wrong OpenDRIVE map in use. Forcing reload of CARLA world") vertex_distance = 2.0 # in meters wall_height = 1.0 # in meters extra_width = 0.6 # in meters world = self.client.generate_opendrive_world(str(data), carla.OpendriveGenerationParameters( vertex_distance=vertex_distance, wall_height=wall_height, additional_width=extra_width, smooth_junctions=True, enable_mesh_visibility=True)) else: self.logger.warning(" Wrong map in use. Forcing reload of CARLA world") self.client.load_world(self.town) world = self.client.get_world() CarlaDataProvider.set_world(world) if CarlaDataProvider.is_sync_mode(): world.tick() else: world.wait_for_tick() else: CarlaDataProvider.set_world(world)