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)
