def _update_route(self, world, config, debug_mode):
"""
Update the input route, i.e. refine waypoint list, and extract possible scenario locations
Parameters:
- world: CARLA world
- config: Scenario configuration (RouteConfiguration)
"""
# Transform the scenario file into a dictionary
world_annotations = RouteParser.parse_annotations_file(config.scenario_file)
# prepare route's trajectory (interpolate and add the GPS route)
gps_route, route = interpolate_trajectory(world, config.trajectory)
potential_scenarios_definitions, _ = RouteParser.scan_route_for_scenarios(
config.town, route, world_annotations)
self.route = route
CarlaDataProvider.set_ego_vehicle_route(convert_transform_to_location(self.route))
config.agent.set_global_plan(gps_route, self.route)
# Sample the scenarios to be used for this route instance.
self.sampled_scenarios_definitions = self._scenario_sampling(potential_scenarios_definitions)
# Timeout of scenario in seconds
self.timeout = self._estimate_route_timeout()
# Print route in debug mode
if debug_mode:
self._draw_waypoints(world, self.route, vertical_shift=1.0, persistency=50000.0)
def load_environment_and_run(self, args):
CarlaDataProvider.set_ego_vehicle_route(
convert_transform_to_location(self.route))
# create agent
self.agent_instance = getattr(self.module_agent,
self.module_agent.__name__)(args.config)
correct_sensors, error_message = self.valid_sensors_configuration(
self.agent_instance, self.track)
if not correct_sensors:
# the sensor configuration is illegal
sys.exit(-1)
# build the master scenario based on the route and the target.
self.master_scenario = self.build_master_scenario(
self.route, args.map, timeout=self.route_timeout)
self.list_scenarios.append(self.master_scenario)
# need to modified to the condition of covergence of RL algorithm !!!
while True:
# reset
self.worldReset()
for scenario in self.list_scenarios:
scenario.scenario.scenario_tree.tick_once()
# main loop!
self.run_route(self.route)
def _set_route(self, hop_resolution=1.0):
world = CarlaDataProvider.get_world()
dao = GlobalRoutePlannerDAO(world.get_map(), hop_resolution)
grp = GlobalRoutePlanner(dao)
grp.setup()
spawn_points = CarlaDataProvider._spawn_points
# start, target = random.choice(spawn_points, size=2)
start_idx, target_idx = random.choice(len(spawn_points), size=2)
# DEBUG
# start_idx, target_idx = 57, 87
# start_idx, target_idx = 2, 18
# print (start_idx, target_idx)
start = spawn_points[start_idx]
target = spawn_points[target_idx]
route = grp.trace_route(start.location, target.location)
self.route = [(w.transform, c) for w, c in route]
CarlaDataProvider.set_ego_vehicle_route([(w.transform.location, c)
for w, c in route])
gps_route = location_route_to_gps(self.route, *_get_latlon_ref(world))
self.config.agent.set_global_plan(gps_route, self.route)
self.timeout = self._estimate_route_timeout()
def _update_route(self, world, config, debug_mode):
"""
Update the input route, i.e. refine waypoint list, and extract possible scenario locations
Parameters:
- world: CARLA world
- config: Scenario configuration (RouteConfiguration)
"""
# Transform the scenario file into a dictionary
world_annotations = RouteParser.parse_annotations_file(config.scenario_file)
# prepare route's trajectory (interpolate and add the GPS route)
gps_route, route = interpolate_trajectory(world, config.trajectory)
if self.customized_data:
sample_factor = self.customized_data['sample_factor']
config.agent.set_global_plan(gps_route, route, sample_factor)
else:
config.agent.set_global_plan(gps_route, route)
if self.customized_data and 'ego_car_waypoints_perturbation' in self.customized_data:
perturb_route(config.agent._global_plan_world_coord, self.customized_data['ego_car_waypoints_perturbation'])
# visualize_route(config.agent._global_plan_world_coord)
# recalculate gps to accomodate the perturbation
lat_ref, lon_ref = _get_latlon_ref(world)
config.agent._global_plan = location_route_to_gps(route, lat_ref, lon_ref)
self.route = config.agent._global_plan_world_coord
potential_scenarios_definitions, _ = RouteParser.scan_route_for_scenarios(config.town, route, world_annotations)
print('\n potential_scenarios_definitions[0] :', len(potential_scenarios_definitions[0]), '\n')
print('\n potential_scenarios_definitions.keys() :', len(potential_scenarios_definitions.keys()), '\n')
CarlaDataProvider.set_ego_vehicle_route(convert_transform_to_location(self.route))
# Sample the scenarios to be used for this route instance.
self.sampled_scenarios_definitions = self._scenario_sampling(potential_scenarios_definitions)
# Timeout of scenario in seconds
self.timeout = self._estimate_route_timeout()
# Print route in debug mode
if debug_mode:
self._draw_waypoints(world, self.route, vertical_shift=1.0, persistency=50000.0)
def _spawn_ego_car(self, start_transform):
"""
Spawn or update all scenario actors according to
a certain start position.
"""
# If ego_vehicle already exists, just update location
# Otherwise spawn ego vehicle
self._ego_actor = CarlaActorPool.request_new_actor(self._vehicle_model, start_transform,
hero=True)
CarlaDataProvider.set_ego_vehicle_route( convert_transform_to_location(self._route))
logging.debug("Created Ego Vehicle")
def _update_route(self, world, config, debug_mode):
"""
Update the input route, i.e. refine waypoint list, and extract possible scenario locations
Parameters:
- world: CARLA world
- config: Scenario configuration (RouteConfiguration)
"""
# retrieve worlds annotations
world_annotations = RouteParser.parse_annotations_file(
config.scenario_file)
_route_description = copy.copy(config.route_description)
# prepare route's trajectory
gps_route, _route_description['trajectory'] = interpolate_trajectory(
world, _route_description['trajectory'])
potential_scenarios_definitions, _ = RouteParser.scan_route_for_scenarios(
_route_description, world_annotations)
self.route = _route_description['trajectory']
self.target = self.route[-1][0]
CarlaDataProvider.set_ego_vehicle_route(
convert_transform_to_location(self.route))
#Commenting this out because we want to run our own agent in pygame mode
#config.agent.set_global_plan(gps_route, self.route)
# Sample the scenarios to be used for this route instance.
self.sampled_scenarios_definitions = self._scenario_sampling(
potential_scenarios_definitions)
# Timeout of scenario in seconds
self.timeout = self._estimate_route_timeout()
# Print route in debug mode
if debug_mode:
turn_positions_and_labels = clean_route(self.route)
self._draw_waypoints(world,
self.route,
turn_positions_and_labels,
vertical_shift=1.0,
persistency=50000.0)
def _set_route(self, hop_resolution=1.0):
world = CarlaDataProvider.get_world()
dao = GlobalRoutePlannerDAO(world.get_map(), hop_resolution)
grp = GlobalRoutePlanner(dao)
grp.setup()
spawn_points = CarlaDataProvider._spawn_points
start = spawn_points[self.start_idx]
target = spawn_points[self.target_idx]
route = grp.trace_route(start.location, target.location)
self.route = [(w.transform, c) for w, c in route]
CarlaDataProvider.set_ego_vehicle_route([(w.transform.location, c)
for w, c in route])
gps_route = location_route_to_gps(self.route, *_get_latlon_ref(world))
self.agent.set_global_plan(gps_route, self.route)
self.timeout = self._estimate_route_timeout()
def test_routes(args):
"""
Run all routes according to provided commandline args
"""
# Routes are always visible
args.route_visible = True
challenge = ChallengeEvaluator(args)
# retrieve worlds annotations
world_annotations = parser.parse_annotations_file(args.scenarios)
# retrieve routes
route_descriptions_list = parser.parse_routes_file(args.routes)
# find and filter potential scenarios for each of the evaluated routes
# For each of the routes and corresponding possible scenarios to be evaluated.
route_description = route_descriptions_list[args.route_id]
# setup world and client assuming that the CARLA server is up and running
client = carla.Client(args.host, int(args.port))
client.set_timeout(challenge.client_timeout)
# load the challenge.world variable to be used during the route
challenge.load_world(client, route_description['town_name'])
# Set the actor pool so the scenarios can prepare themselves when needed
CarlaActorPool.set_client(client)
CarlaActorPool.set_world(challenge.world)
# Also se the Data provider pool.
CarlaDataProvider.set_world(challenge.world)
# tick world so we can start.
challenge.world.tick()
# prepare route's trajectory
gps_route, route_description['trajectory'] = interpolate_trajectory(
challenge.world, route_description['trajectory'])
CarlaDataProvider.set_ego_vehicle_route(
convert_transform_to_location(route_description['trajectory']))
potential_scenarios_definitions, existent_triggers = parser.scan_route_for_scenarios(
route_description, world_annotations)
potential_scenarios_definitions = challenge.filter_scenarios(
potential_scenarios_definitions, args.removed_scenarios)
print("WE HAVE This number of posibilities : ",
len(potential_scenarios_definitions))
# Sample the scenarios to be used for this route instance.
sampled_scenarios_definitions = challenge.scenario_sampling(
potential_scenarios_definitions)
# create agent
challenge.agent_instance = getattr(
challenge.module_agent, challenge.module_agent.__name__)(args.config)
correct_sensors, error_message = challenge.valid_sensors_configuration(
challenge.agent_instance, challenge.track)
if not correct_sensors:
# the sensor configuration is illegal
challenge.report_fatal_error(args.filename, args.show_to_participant,
error_message)
return
challenge.agent_instance.set_global_plan(gps_route,
route_description['trajectory'])
# prepare the ego car to run the route.
# It starts on the first wp of the route
elevate_transform = route_description['trajectory'][0][0]
elevate_transform.location.z += 0.5
challenge.prepare_ego_car(elevate_transform)
# build the master scenario based on the route and the target.
challenge.master_scenario = challenge.build_master_scenario(
route_description['trajectory'], route_description['town_name'])
list_scenarios = [challenge.master_scenario]
if args.background:
background_scenario = challenge.build_background_scenario(
route_description['town_name'])
list_scenarios.append(background_scenario)
# build the instance based on the parsed definitions.
print("Definition of the scenarios present on the route ")
pprint(sampled_scenarios_definitions)
list_scenarios += challenge.build_scenario_instances(
sampled_scenarios_definitions, route_description['town_name'])
if args.debug > 0:
for scenario in sampled_scenarios_definitions:
loc = carla.Location(
scenario['trigger_position']['x'],
scenario['trigger_position']['y'],
scenario['trigger_position']['z']) + carla.Location(z=2.0)
challenge.world.debug.draw_point(loc,
size=1.0,
color=carla.Color(255, 0, 0),
life_time=100000)
challenge.world.debug.draw_string(loc,
scenario['name'],
draw_shadow=False,
color=carla.Color(0, 0, 255),
life_time=100000,
persistent_lines=True)
# Tick once to start the scenarios.
print(" Running these scenarios --- ", list_scenarios)
for scenario in list_scenarios:
scenario.scenario.scenario_tree.tick_once()
challenge.run_route(list_scenarios, route_description['trajectory'])
# statistics recording
challenge.record_route_statistics(route_description['id'])
# clean up
for scenario in list_scenarios:
scenario.remove_all_actors()
challenge.cleanup(ego=True)
challenge.agent_instance.destroy()
