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()