def _run_scenarios(self):
"""
Run conventional scenarios (e.g. implemented using the Python API of ScenarioRunner)
"""
result = False
# Setup and run the scenarios for repetition times
for _ in range(int(self._args.repetitions)):
# Load the scenario configurations provided in the config file
scenario_configurations = None
scenario_config_file = ScenarioConfigurationParser.find_scenario_config(
self._args.scenario, self._args.configFile)
if scenario_config_file is None:
print("Configuration for scenario {} cannot be found!".format(
self._args.scenario))
continue
scenario_configurations = ScenarioConfigurationParser.parse_scenario_configuration(
scenario_config_file, self._args.scenario)
# Execute each configuration
for config in scenario_configurations:
result = self._load_and_run_scenario(config)
self._cleanup()
return result
def _run_scenarios(self, args):
"""
Run conventional scenarios (e.g. implemented using the Python API of ScenarioRunner)
"""
# Setup and run the scenarios for repetition times
for _ in range(int(args.repetitions)):
# Load the scenario configurations provided in the config file
scenario_configurations = None
scenario_config_file = ScenarioConfigurationParser.find_scenario_config(
args.scenario, args.configFile)
if scenario_config_file is None:
print("Configuration for scenario {} cannot be found!".format(
args.scenario))
continue
scenario_configurations = ScenarioConfigurationParser.parse_scenario_configuration(
scenario_config_file, args.scenario)
# Execute each configuration
for config in scenario_configurations:
self._load_and_run_scenario(args, config)
self._cleanup(ego=(not args.waitForEgo))
print("No more scenarios .... Exiting")
def run(self, args):
scenario_config_file = ScenarioConfigurationParser.find_scenario_config(args.scenario, args.configFile) # xml file
####################################
print(args.configFile)
print(scenario_config_file)
print(args.scenario)
scenario_configurations = parse_rss_scenario_configuration(scenario_config_file, args.scenario)
config = scenario_configurations[0] # since we work only with one scenario!
# Defaults except for ones we set
# Lon accel max: 3.500
# Lon brake max: 8.000
# Lon brake min: 4.000
# Lon brake min correct: 0.100
# Lat accel max: 0.200
# Lat brake min: 0.800
# Lat fluct mar: 0.000
# Response time: 0.200
g = 9.8
rss_params = {}
rss_params['alpha_lon_accel_max'] = 0.5*g
rss_params['alpha_lon_brake_max'] = 0.7*g
rss_params['response_time'] = 0.2
rss_params['alpha_lon_brake_min'] = 0.5*g
print('RSS params: %s' % rss_params)
# Load the world once
self.load_world(config.town)
settings = self.world.get_settings()
settings.fixed_delta_seconds = 0.015
self.world.apply_settings(settings)
# Set the sun to be directly overhead
weather = carla.WeatherParameters(sun_altitude_angle=90)
self.world.set_weather(weather)
return self.simulate(config, args, rss_params)
def main():
"""
main function
"""
description = (
"CARLA Scenario Runner: Setup, Run and Evaluate scenarios using CARLA\n"
"Current version: " + str(VERSION))
parser = argparse.ArgumentParser(description=description,
formatter_class=RawTextHelpFormatter)
parser.add_argument('--host',
default='127.0.0.1',
help='IP of the host server (default: localhost)')
parser.add_argument('--port',
default='2000',
help='TCP port to listen to (default: 2000)')
parser.add_argument('--debug',
action="store_true",
help='Run with debug output')
parser.add_argument('--output',
action="store_true",
help='Provide results on stdout')
parser.add_argument('--file',
action="store_true",
help='Write results into a txt file')
parser.add_argument('--junit',
action="store_true",
help='Write results into a junit file')
parser.add_argument(
'--outputDir',
default='',
help='Directory for output files (default: this directory)')
parser.add_argument('--waitForEgo',
action="store_true",
help='Connect the scenario to an existing ego vehicle')
parser.add_argument(
'--configFile',
default='',
help='Provide an additional scenario configuration file (*.xml)')
parser.add_argument(
'--additionalScenario',
default='',
help='Provide additional scenario implementations (*.py)')
parser.add_argument(
'--reloadWorld',
action="store_true",
help='Reload the CARLA world before starting a scenario (default=True)'
)
# pylint: disable=line-too-long
parser.add_argument(
'--scenario',
help=
'Name of the scenario to be executed. Use the preposition \'group:\' to run all scenarios of one class, e.g. ControlLoss or FollowLeadingVehicle'
)
parser.add_argument('--randomize',
action="store_true",
help='Scenario parameters are randomized')
parser.add_argument('--repetitions',
default=1,
help='Number of scenario executions')
parser.add_argument('--list',
action="store_true",
help='List all supported scenarios and exit')
parser.add_argument(
'--agent',
help=
"Agent used to execute the scenario (optional). Currently only compatible with route-based scenarios."
)
parser.add_argument('--agentConfig',
type=str,
help="Path to Agent's configuration file",
default="")
parser.add_argument('--openscenario',
help='Provide an OpenSCENARIO definition')
parser.add_argument(
'--route',
help=
'Run a route as a scenario, similar to the CARLA AD challenge (input: (route_file,scenario_file,[number of route]))',
nargs='+',
type=str)
parser.add_argument('--challenge',
action="store_true",
help='Run in challenge mode')
parser.add_argument(
'--record',
action="store_true",
help='Use CARLA recording feature to create a recording of the scenario'
)
parser.add_argument('--timeout',
default="10.0",
help='Set the CARLA client timeout value in seconds')
parser.add_argument('-v',
'--version',
action='version',
version='%(prog)s ' + str(VERSION))
arguments = parser.parse_args()
# pylint: enable=line-too-long
if arguments.list:
print("Currently the following scenarios are supported:")
print(*ScenarioConfigurationParser.get_list_of_scenarios(
arguments.configFile),
sep='\n')
return 1
if not arguments.scenario and not arguments.openscenario and not arguments.route:
print("Please specify either a scenario or use the route mode\n\n")
parser.print_help(sys.stdout)
return 1
if (arguments.route
and arguments.openscenario) or (arguments.route
and arguments.scenario):
print(
"The route mode cannot be used together with a scenario (incl. OpenSCENARIO)'\n\n"
)
parser.print_help(sys.stdout)
return 1
if arguments.agent and (arguments.openscenario or arguments.scenario):
print("Agents are currently only compatible with route scenarios'\n\n")
parser.print_help(sys.stdout)
return 1
if arguments.challenge and (arguments.openscenario or arguments.scenario):
print(
"The challenge mode can only be used with route-based scenarios'\n\n"
)
parser.print_help(sys.stdout)
return 1
if arguments.route:
arguments.reloadWorld = True
scenario_runner = None
result = True
try:
scenario_runner = ScenarioRunner(arguments)
result = scenario_runner.run()
finally:
if arguments.challenge:
ChallengeStatisticsManager.report_challenge_statistics(
'results.json', arguments.debug)
if scenario_runner is not None:
scenario_runner.destroy()
del scenario_runner
return not result
PARSER.add_argument(
'--route',
help=
'Run a route as a scenario, similar to the CARLA AD challenge (input: (route_file,scenario_file,[number of route]))',
nargs='+',
type=str)
PARSER.add_argument('-v',
'--version',
action='version',
version='%(prog)s ' + str(VERSION))
ARGUMENTS = PARSER.parse_args()
# pylint: enable=line-too-long
if ARGUMENTS.list:
print("Currently the following scenarios are supported:")
print(*ScenarioConfigurationParser.get_list_of_scenarios(
ARGUMENTS.configFile),
sep='\n')
sys.exit(0)
if ARGUMENTS.listClass:
print("Currently the following scenario classes are supported:")
print(*SCENARIOS.keys(), sep='\n')
sys.exit(0)
if not ARGUMENTS.scenario and not ARGUMENTS.openscenario and not ARGUMENTS.route:
print("Please specify either a scenario or use the route mode\n\n")
PARSER.print_help(sys.stdout)
sys.exit(0)
if (ARGUMENTS.route
and ARGUMENTS.openscenario) or (ARGUMENTS.route
def run(self, args):
scenario_config_file = ScenarioConfigurationParser.find_scenario_config(
args.scenario, args.configFile) # xml file
num_simult_runs = 1
nruns = 20
####################################
search_names = [
'alpha_lon_accel_max', 'alpha_lon_brake_max',
'alpha_lon_brake_min', 'response_time', 'alpha_lat_accel_max',
'alpha_lat_brake_min', 'lateral_fluctuation_margin'
] #, 'alpha_lon_brake_min_correct']
# extra params for lateral and opposite directions :
# 'alpha_lat_brake_min', 'lateral_fluctuation_margin', 'alpha_lon_brake_min_correct', 'alpha_lat_accel_max'
## initial values ?
alpha_lon_accel_max = 3.5
response_time = 1.0
alpha_lon_brake_max = 6.0
alpha_lon_brake_min = 3.5
alpha_lat_accel_max = 0.1
alpha_lat_brake_min = 0.1
lateral_fluctuation_margin = 0.1
alpha_lon_brake_min_correct = 1.0
# alpha_lon_accel_max = 4.01
# response_time = 0.53
# alpha_lon_brake_max = 8.03
# alpha_lon_brake_min = 4.64
# alpha_lat_accel_max = 0.43
# alpha_lat_brake_min = 0.96
# lateral_fluctuation_margin = 0.07
# alpha_lon_brake_min_correct = 1.76
####################################
x0, searchSpace = RssParamsInit().getInit(
search_names,
alpha_lon_accel_max=alpha_lon_accel_max,
response_time=response_time,
alpha_lon_brake_max=alpha_lon_brake_max,
alpha_lon_brake_min=alpha_lon_brake_min,
alpha_lat_accel_max=alpha_lat_accel_max,
alpha_lat_brake_min=alpha_lat_brake_min,
lateral_fluctuation_margin=lateral_fluctuation_margin)
# , alpha_lon_brake_min_correct = alpha_lon_brake_min_correct)
# search_names = ['alpha_lon_accel_max', 'response_time']
# alpha_lon_accel_max = 3.5
# response_time = 1.0
# ####################################
# x0, searchSpace = RssParamsInit().getInit(search_names,
# alpha_lon_accel_max = alpha_lon_accel_max,
# response_time = response_time)
print('X0 = %s' % x0)
print('SearchSpace = %s\n' % searchSpace)
#-------------------------------
X0 = []
for _ in range(num_simult_runs):
X0.append(x0)
####################################
####################################
def ff(x):
scenario_configurations = parse_rss_scenario_configuration(
scenario_config_file, args.scenario)
config = scenario_configurations[
0] # since we work only with one scenario!
rss_params = defineRssParams(x, search_names)
rss_params['alpha_lon_brake_min_correct'] = 0.1
print('RSS params: %s' % rss_params)
return self.simulate(config, args, rss_params)
# reproduce trajs
'''
for i in range(10):
self.filename_traj = os.path.join(RES_FOLDER, ('trajectory'+str(i)+'.csv'))
ff(x0)
'''
best_x_history, best_f_history, x_history, f_history, accept_x_history, accept_flags = annealing.runFunc(
ff, X0, searchSpace, nruns, num_simult_runs, RES_FOLDER)