def __init__(self, map_filename, track_filename, starting_offset_ms = 0):
self._map_filename = map_filename
self._track_filename = track_filename
self._starting_offset_ms = starting_offset_ms
self._track_dict = dataset_reader.read_tracks(track_filename)
self._map_interface = self.__setup_map_interface__()
self._agents_track_infos = self.__setup_agents_track_infos__()
def TrackFromTrackfile(self, filename, track_id):
if filename not in self._track_dict_cache:
self._track_dict_cache[filename] = dataset_reader.read_tracks(
filename)
track = self._track_dict_cache[filename][track_id]
# TODO: Filter track
return track
def create_from_config(self, config_param_object, road_corridor):
track_file_name = config_param_object["TrackFilename", "Path to track file (csv)",
"bark/runtime/tests/data/interaction_dataset_dummy_track.csv"]
track_ids = config_param_object["TrackIds", "IDs of the vehicle tracks to import.", [1]]
start_time = config_param_object["StartTs", "Timestamp when to start the scenario (ms)", 0]
end_time = config_param_object["EndTs","Timestamp when to end the scenario (ms)", None]
wheel_base = config_param_object["WheelBase", "Wheelbase assumed for shape calculation", 2.7]
agent_geometries = []
agent_states = []
lane_positions = []
tracks = []
for track_id in track_ids:
tracks_read = dataset_reader.read_tracks(track_file_name)
track = tracks_read[track_id]
if start_time is None:
start_time = track.time_stamp_ms_first
if end_time is None:
end_time = track.time_stamp_ms_last
numpy_state = InitStateFromTrack(track, start_time)
agent_state = numpy_state.reshape(5).tolist()
agent_states.append(agent_state)
shape = ShapeFromTrack(track, wheel_base)
agent_geometries.append(shape)
tracks.append(track)
lane_positions_agent = self.find_lane_positions(numpy_state, road_corridor)
lane_positions.append(lane_positions_agent)
assert(len(agent_states) == len(agent_geometries))
return agent_states, agent_geometries, {"track_ids": track_ids, "tracks" : tracks, \
"agent_ids" : track_ids, "start_time" : start_time, "end_time" : end_time, \
"agent_lane_positions" : lane_positions}, config_param_object
def load_tracks(self, track_filenames):
track_dict_list = []
if isinstance(track_filenames, list):
track_files_found = track_filenames
else:
track_files_found = glob.glob(track_filenames)
for filename in track_files_found:
track_dict = dataset_reader.read_tracks(filename)
track_dict_list.append(track_dict)
return track_dict_list
def TrackFromTrackfile(self, filename, track_id):
if filename not in self._track_dict_cache:
try:
self._track_dict_cache[filename] = dataset_reader.read_tracks(
filename)
except FileNotFoundError as e:
logging.error("File {} not found!".format(
os.path.abspath(filename)))
exit(1)
track = self._track_dict_cache[filename][track_id]
# TODO: Filter track
return track
def __init__(self,
map_interface,
road_corridor,
track_filename,
vehicle_length_max,
xy_offset,
starting_offset_ms=0):
self._map_interface = map_interface
self._track_filename = track_filename
self._starting_offset_ms = starting_offset_ms
self._xy_offset = xy_offset
self._vehicle_length_max = vehicle_length_max
self._road_corridor = road_corridor
self._track_dict = dataset_reader.read_tracks(track_filename)
self._agents_track_infos = self.__setup_agents_track_infos__()
def __init__(self, map_filename, track_filename):
self.map_filename = map_filename
self.track_filename = track_filename
self.track_dict = dataset_reader.read_tracks(track_filename)
def track_from_trackfile(filename, track_id):
track_dictionary = dataset_reader.read_tracks(filename)
track = track_dictionary[track_id]
return track
