def __init__(self, routes_file, scenarios_file, repetitions):
self._routes_file = routes_file
self._scenarios_file = scenarios_file
self._repetitions = repetitions
self._configs_dict = OrderedDict()
self._configs_list = None
self.routes_length = []
self._index = 0
# retrieve routes
route_descriptions_list = RouteParser.parse_routes_file(
self._routes_file, False)
self.n_routes = len(route_descriptions_list)
self.total = self.n_routes * self._repetitions
for i, route_description in enumerate(route_descriptions_list):
for repetition in range(repetitions):
config = RouteScenarioConfiguration(route_description,
self._scenarios_file)
config.index = i * self._repetitions + repetition
self._configs_dict['{}.{}'.format(config.name,
repetition)] = config
self._configs_list = list(self._configs_dict.items())
def _run_challenge(self, args):
"""
Run the challenge mode
"""
routes = args.route[0]
scenario_file = args.route[1]
single_route = None
if args.route[2]:
single_route = args.route[2]
repetitions = 1
# retrieve routes
route_descriptions_list = RouteParser.parse_routes_file(
routes, single_route)
# find and filter potential scenarios for each of the evaluated routes
# For each of the routes and corresponding possible scenarios to be evaluated.
# n_routes = len(route_descriptions_list) * repetitions
for _, route_description in enumerate(route_descriptions_list):
for _ in range(repetitions):
config = RouteScenarioConfiguration(route_description,
scenario_file)
self._load_and_run_scenario(args, config)
self._cleanup(ego=(not args.waitForEgo))
def _run_route(self):
"""
Run the route scenario
"""
result = False
repetitions = self._args.repetitions
if self._args.route:
routes = self._args.route[0]
scenario_file = self._args.route[1]
single_route = None
if len(self._args.route) > 2:
single_route = self._args.route[2]
# retrieve routes
route_descriptions_list = RouteParser.parse_routes_file(
routes, single_route)
# find and filter potential scenarios for each of the evaluated routes
# For each of the routes and corresponding possible scenarios to be evaluated.
for _, route_description in enumerate(route_descriptions_list):
for _ in range(repetitions):
config = RouteScenarioConfiguration(route_description,
scenario_file)
result = self._load_and_run_scenario(config, -1, -1)
self._cleanup()
return result
def parse_routes_file(route_filename, scenario_file, single_route=None):
"""
Returns a list of route elements.
:param route_filename: the path to a set of routes.
:param single_route: If set, only this route shall be returned
:return: List of dicts containing the waypoints, id and town of the routes
"""
list_route_descriptions = []
tree = ET.parse(route_filename)
for route in tree.iter("route"):
route_id = route.attrib['id']
if single_route and route_id != single_route:
continue
new_config = RouteScenarioConfiguration()
new_config.town = route.attrib['town']
new_config.name = "RouteScenario_{}".format(route_id)
new_config.weather = RouteParser.parse_weather(route)
new_config.scenario_file = scenario_file
waypoint_list = [] # the list of waypoints that can be found on this route
for waypoint in route.iter('waypoint'):
waypoint_list.append(carla.Location(x=float(waypoint.attrib['x']),
y=float(waypoint.attrib['y']),
z=float(waypoint.attrib['z'])))
new_config.trajectory = waypoint_list
list_route_descriptions.append(new_config)
return list_route_descriptions
def createScenarioConfig(self, result=None):
self.scenario = self.scenarioGenerator.generateScenario(result)
if not self.scenario or self.wp_idx + 7 >= len(self.waypoint_list):
return None
location = carla.Location(self.waypoint_list[self.wp_idx + 2][0],
self.waypoint_list[self.wp_idx + 2][1],
self.waypoint_list[self.wp_idx + 2][2])
trigger_points = []
for i in range(len(self.scenario)):
if i != 0:
trigger_point = self.map.get_waypoint(
location,
project_to_road=True,
lane_type=carla.LaneType.Driving).next(10 * i)[0].transform
else:
trigger_point = self.map.get_waypoint(
location,
project_to_road=True,
lane_type=carla.LaneType.Driving).transform
trigger_points.append(trigger_point)
scenarioConfig = ScenarioConfig(self.track)
scenario_config = scenarioConfig.getScenario(self.scenario,
trigger_points)
print("Config: ", scenario_config)
route_config_list = []
route_config = RouteScenarioConfiguration()
route_config.town = self.track
route_config.name = 'RouteScenario_0'
route_config.weather = carla.WeatherParameters(sun_altitude_angle=70)
route_config.scenario_config = scenario_config
wp = []
wp.append(
carla.Location(x=self.waypoint_list[self.wp_idx][0],
y=self.waypoint_list[self.wp_idx][1],
z=self.waypoint_list[self.wp_idx][2]))
wp.append(
carla.Location(x=self.waypoint_list[self.wp_idx + 6][0],
y=self.waypoint_list[self.wp_idx + 6][1],
z=self.waypoint_list[self.wp_idx + 6][2]))
route_config.trajectory = wp
route_config_list.append(route_config)
args = ScenarioArguments(route_config_list,
scenario_config,
port=self.port)
self.wp_idx += 7
return args
def _run_challenge(self):
"""
Run the challenge mode
"""
result = False
phase_codename = os.getenv('CHALLENGE_PHASE_CODENAME', 'dev_track_3')
phase = phase_codename.split("_")[0]
repetitions = self._args.repetitions
if self._args.challenge:
weather_profiles = CarlaDataProvider.find_weather_presets()
scenario_runner_root = os.getenv('ROOT_SCENARIO_RUNNER', "./")
if phase == 'dev':
routes = '{}/srunner/challenge/routes_devtest.xml'.format(
scenario_runner_root)
repetitions = 1
elif phase == 'validation':
routes = '{}/srunner/challenge/routes_testprep.xml'.format(
scenario_runner_root)
repetitions = 3
elif phase == 'test':
routes = '{}/srunner/challenge/routes_testchallenge.xml'.format(
scenario_runner_root)
repetitions = 3
else:
# debug mode
routes = '{}/srunner/challenge/routes_debug.xml'.format(
scenario_runner_root)
repetitions = 1
if self._args.route:
routes = self._args.route[0]
scenario_file = self._args.route[1]
single_route = None
if len(self._args.route) > 2:
single_route = self._args.route[2]
# retrieve routes
route_descriptions_list = RouteParser.parse_routes_file(
routes, single_route)
# find and filter potential scenarios for each of the evaluated routes
# For each of the routes and corresponding possible scenarios to be evaluated.
if self._args.challenge:
n_routes = len(route_descriptions_list) * repetitions
ChallengeStatisticsManager.set_number_of_scenarios(n_routes)
for _, route_description in enumerate(route_descriptions_list):
for repetition in range(repetitions):
if self._args.challenge and not self._within_available_time():
error_message = 'Not enough simulation time available to continue'
print(error_message)
ChallengeStatisticsManager.record_fatal_error(
error_message)
self._cleanup()
return False
config = RouteScenarioConfiguration(route_description,
scenario_file)
if self._args.challenge:
profile = weather_profiles[repetition %
len(weather_profiles)]
config.weather = profile[0]
config.weather.sun_azimuth_angle = -1
config.weather.sun_altitude_angle = -1
result = self._load_and_run_scenario(config)
self._cleanup()
return result