def test_route_parser(self): args = Arguments() client = carla.Client(args.host, int(args.port)) client.set_timeout(25.0) challenge = ChallengeEvaluator(args) filename = os.path.join(self.root_route_file_position, 'all_towns_traffic_scenarios.json') world_annotations = parser.parse_annotations_file(filename) # retrieve routes # Which type of file is expected ???? filename = os.path.join(self.root_route_file_position, 'routes_training.xml') list_route_descriptions = parser.parse_routes_file(filename) # For each of the routes to be evaluated. for route_description in list_route_descriptions: if route_description['town_name'] == 'Town03' or route_description[ 'town_name'] == 'Town01': continue print(" TOWN: ", route_description['town_name']) challenge.world = client.load_world(route_description['town_name']) # Set the actor pool so the scenarios can prepare themselves when needed CarlaActorPool.set_world(challenge.world) CarlaDataProvider.set_world(challenge.world) # find and filter potential scenarios # Returns the interpolation in a different format challenge.world.wait_for_tick() gps_route, route_description[ 'trajectory'] = interpolate_trajectory( challenge.world, route_description['trajectory']) potential_scenarios_definitions, existent_triggers = parser.scan_route_for_scenarios( route_description, world_annotations) for trigger_id, possible_scenarios in potential_scenarios_definitions.items( ): print(" For trigger ", trigger_id, " -- ", possible_scenarios[0]['trigger_position']) for scenario in possible_scenarios: print(" ", scenario['name']) challenge.cleanup(ego=True)
def test_possible_spawns(self): args = Arguments() client = carla.Client(args.host, int(args.port)) client.set_timeout(25.0) challenge = ChallengeEvaluator(args) filename = os.path.join(self.root_route_file_position, 'routes_training.xml') list_route_descriptions = parser.parse_routes_file(filename) # Which type of file is expected ???? # For each of the routes to be evaluated. for route_description in list_route_descriptions: challenge.world = client.load_world(route_description['town_name']) # Set the actor pool so the scenarios can prepare themselves when needed CarlaActorPool.set_world(challenge.world) CarlaDataProvider.set_world(challenge.world) # find and filter potential scenarios # Returns the iterpolation in a different format challenge.world.wait_for_tick() gps_route, route_description[ 'trajectory'] = interpolate_trajectory( challenge.world, route_description['trajectory']) #print (gps_route) #print (route_description['trajectory']) elevate_transform = route_description['trajectory'][0][0].transform elevate_transform.location.z += 0.5 #print (elevate_transform) challenge.prepare_ego_car(elevate_transform) challenge.cleanup(ego=True)
def test_routes(args): """ Run all routes according to provided commandline args """ # instance a challenge challenge = ChallengeEvaluator(args) # retrieve worlds annotations world_annotations = parser.parse_annotations_file(args.scenarios) # retrieve routes routes = [] route_descriptions_list = parser.parse_routes_file(args.routes) for route_description in route_descriptions_list: if route_description['town_name'] == args.debug_town: routes.append(route_description) # find and filter potential scenarios for each of the evaluated routes # For each of the routes and corresponding possible scenarios to be evaluated. list_scenarios_town = [] if args.debug_town in world_annotations.keys(): list_scenarios_town = world_annotations[args.debug_town] scenarios_current_type = [] for scenario in list_scenarios_town: if args.debug_scenario == scenario['scenario_type']: scenarios_current_type = scenario break for scenario_configuration in scenarios_current_type[ 'available_event_configurations']: scenario_conf = create_configuration_scenario(scenario_configuration, args.debug_scenario) 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, args.debug_town) # Set the actor pool so the scenarios can prepare themselves when needed 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() # 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 waypoint = routes[0]['trajectory'][0] location = carla.Location(x=float(waypoint.attrib['x']), y=float(waypoint.attrib['y']), z=float(waypoint.attrib['z'])) rotation = carla.Rotation(pitch=float(waypoint.attrib['pitch']), yaw=float(waypoint.attrib['yaw'])) challenge.prepare_ego_car(carla.Transform(location, rotation)) CarlaDataProvider.register_actor(challenge.ego_vehicle) list_scenarios = [] list_scenarios += challenge.build_scenario_instances([scenario_conf], args.debug_town) # 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, None, True) # clean up for scenario in list_scenarios: del scenario challenge.cleanup(ego=True) challenge.agent_instance.destroy() break # final measurements from the challenge challenge.report_challenge_statistics(args.filename, args.show_to_participant) del challenge
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()
def test_build_scenarios(self): args = Arguments() client = carla.Client(args.host, int(args.port)) client.set_timeout(25.0) challenge = ChallengeEvaluator(args) filename = os.path.join(self.root_route_file_position, 'all_towns_traffic_scenarios1_3_4.json') world_annotations = parser.parse_annotations_file(filename) # retrieve routes # Which type of file is expected ???? filename_train = os.path.join(self.root_route_file_position, 'routes_training.xml') filename_val = os.path.join(self.root_route_file_position, 'routes_devtest.xml') list_route_descriptions = parser.parse_routes_file( filename_train) + parser.parse_routes_file(filename_val) # For each of the routes to be evaluated. for route_description in list_route_descriptions: if route_description['town_name'] == 'Town03'\ or route_description['town_name'] == 'Town04': continue # or route_description['town_name'] == 'Town02': # continue print(" TOWN ", route_description['town_name']) challenge.world = client.load_world(route_description['town_name']) CarlaActorPool.set_client(client) # Set the actor pool so the scenarios can prepare themselves when needed CarlaActorPool.set_world(challenge.world) CarlaDataProvider.set_world(challenge.world) # find and filter potential scenarios # Returns the iterpolation in a different format challenge.world.wait_for_tick() gps_route, route_description[ 'trajectory'] = interpolate_trajectory( challenge.world, route_description['trajectory']) potential_scenarios_definitions, existent_triggers = parser.scan_route_for_scenarios( route_description, world_annotations) # Sample the scenarios sampled_scenarios = challenge.scenario_sampling( potential_scenarios_definitions) # prepare route's trajectory 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. print("loading master") master_scenario = challenge.build_master_scenario( route_description['trajectory'], route_description['town_name']) list_scenarios = [master_scenario] if args.background: background_scenario = challenge.build_background_scenario( route_description['town_name']) list_scenarios.append(background_scenario) print(" Built the master scenario ") # build the instance based on the parsed definitions. print(sampled_scenarios) # remove scenario 8 and 9 scenario_removed = [] for possible_scenario in sampled_scenarios: if possible_scenario['name'] == 'Scenario8' or possible_scenario['name'] == 'Scenario7' or \ possible_scenario['name'] == 'Scenario9' or possible_scenario['name'] == 'Scenario5': continue else: scenario_removed.append(possible_scenario) list_scenarios += challenge.build_scenario_instances( scenario_removed, route_description['town_name']) print(" Scenarios present ", list_scenarios) challenge.cleanup(ego=True)
def test_possible_spawns(self): args = Arguments() client = carla.Client(args.host, int(args.port)) client.set_timeout(25.0) challenge = ChallengeEvaluator(args) filename = os.path.join(self.root_route_file_position, 'all_towns_traffic_scenarios.json') world_annotations = parser.parse_annotations_file(filename) # retrieve routes # Which type of file is expected ???? # For each of the routes to be evaluated. print(" all keys ", world_annotations.keys()) list_failed = [] for town_name in world_annotations.keys(): if town_name == 'Town06': continue challenge.world = client.load_world(town_name) CarlaActorPool.set_world(challenge.world) CarlaDataProvider.set_world(challenge.world) print("Town Name ", town_name) scenarios = world_annotations[town_name] for scenario in scenarios: # For each existent scenario print("Scenario ", scenario['scenario_type']) for event in scenario["available_event_configurations"]: waypoint = event['transform'] convert_waypoint_float(waypoint) print("Spawn ", waypoint) try: challenge.prepare_ego_car( convert_json_to_transform(waypoint)) except: traceback.print_exc() list_failed.append((waypoint, town_name)) challenge.world.wait_for_tick() if 'other_actors' in event: if 'left' in event['other_actors']: for other_waypoint in event['other_actors'][ 'left']: try: challenge.prepare_ego_car( convert_json_to_transform( other_waypoint)) except: traceback.print_exc() list_failed.append((waypoint, town_name)) challenge.world.wait_for_tick() print("Spawn left", other_waypoint) if 'right' in event['other_actors']: for other_waypoint in event['other_actors'][ 'right']: try: challenge.prepare_ego_car( convert_json_to_transform( other_waypoint)) except: traceback.print_exc() list_failed.append((waypoint, town_name)) challenge.world.wait_for_tick() print("Spawn right", other_waypoint) if 'front' in event['other_actors']: for other_waypoint in event['other_actors'][ 'front']: try: challenge.prepare_ego_car( convert_json_to_transform( other_waypoint)) except: traceback.print_exc() list_failed.append((waypoint, town_name)) challenge.world.wait_for_tick() print("Spawn front", other_waypoint) challenge.cleanup(ego=True) print("Failed Scenarios ", list_failed)