def load_sdd_dir(path: str, **kwargs): search_filter_str = "**/annotations.txt" if not path.endswith("/"): search_filter_str = "/" + search_filter_str files_list = sorted(glob.glob(path + search_filter_str, recursive=True)) scales_yaml_file = os.path.join(path, 'estimated_scales.yaml') with open(scales_yaml_file, 'r') as f: scales_yaml_content = yaml.load(f, Loader=yaml.FullLoader) partial_datasets = [] for file in files_list: dir_names = file.split('/') scene_name = dir_names[-3] scene_video_id = dir_names[-2] scale = scales_yaml_content[scene_name][scene_video_id]['scale'] partial_dataset = load_sdd(file, scale=scale, scene_id=scene_name + scene_video_id.replace('video', '')) partial_datasets.append(partial_dataset.data) traj_dataset = TrajDataset() traj_dataset.data = pd.concat(partial_datasets) fps = 30 sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def load_bottleneck(path, **kwargs): traj_dataset = TrajDataset() csv_columns = ["agent_id", "frame_id", "pos_x", "pos_y", "pos_z"] # read from csv => fill traj table raw_dataset = pd.read_csv(path, sep=r"\s+", header=None, names=csv_columns) # convert from cm => meter raw_dataset["pos_x"] = raw_dataset["pos_x"] / 100. raw_dataset["pos_y"] = raw_dataset["pos_y"] / 100. traj_dataset.title = kwargs.get('title', "no_title") # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', 16) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) transform = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]]) traj_dataset.apply_transformation(transform, inplace=True) return traj_dataset
def load_lcas(path, **kwargs): traj_dataset = TrajDataset() traj_dataset.title = "LCAS" minerva_files_list = glob.glob(path + "/minerva/**/data.csv") minerva_columns = [ 'frame_id', 'person_id', 'pos_x', 'pos_y', 'rot_z', 'rot_w', 'scene_id' ] # read from minerva data.csv minerva_raw_dataset = [] # This load data from all files for file in minerva_files_list: data = pd.read_csv(file, sep=",", header=None, names=minerva_columns) minerva_raw_dataset.append(data) minerva_raw_dataset = pd.concat(minerva_raw_dataset) minerva_raw_dataset['scene_id'] = 'minerva' minerva_raw_dataset.reset_index(inplace=True, drop=True) traj_dataset.title = kwargs.get('title', "LCAS") traj_dataset.data[["frame_id", "agent_id","pos_x", "pos_y","scene_id"]] = \ minerva_raw_dataset[["frame_id", "person_id","pos_x","pos_y","scene_id"]] traj_dataset.data["label"] = "pedestrian" # post-process. For LCAS, raw data do not include velocity, velocity info is postprocessed fps = kwargs.get('fps', 2.5) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def load_crowds(path, **kwargs): """:param path: string, path to folder""" # pass the homography matrix as well homog_file = kwargs.get("homog_file", "") Homog = ( np.loadtxt(homog_file)) if os.path.exists(homog_file) else np.eye(3) raw_dataset = pd.DataFrame() data = CrowdLoader(Homog).load(path) raw_dataset["frame_id"] = [data[i].frame for i in range(len(data))] raw_dataset["agent_id"] = [data[i].pedestrian for i in range(len(data))] raw_dataset["pos_x"] = [data[i].x for i in range(len(data))] raw_dataset["pos_y"] = [data[i].y for i in range(len(data))] traj_dataset = TrajDataset() traj_dataset.title = kwargs.get('title', "Crowds") # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', 25) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def min_dist_plot(dataset: TrajDataset): frames = dataset.get_frames() min_dists = np.ones(len(frames)) * 1000 # a big number for ii, frame in enumerate(frames): N_t = len(frame) if N_t < 2: continue X_t = frame[["pos_x", "pos_y"]].to_numpy() # compute distance matrix between all pairs of agents DD_t = euclidean_distances(X_t) DD_t = DD_t[~np.eye(N_t, dtype=bool)].reshape(N_t, N_t - 1) min_DD_t = np.amin(DD_t) min_dists[ii] = min_DD_t bins = np.linspace(0, 4, 40) hist, bins, patches = plt.hist(min_dists, bins, color='green', density=True, alpha=0.7) plt.title(dataset.title) plt.ylabel('histogram of min distances') plt.xlabel('meter') plt.xlim([bins[0], bins[-1]]) plt.ylim([0, 2]) return hist
def path_efficiency_plot(dataset: TrajDataset): ped_trajectories = dataset.get_trajectories() efficiencies = [] for traj in ped_trajectories: if len(traj) < 2: continue try: p_eff = path_efficiency(traj) efficiencies.append(p_eff * 100) except: print('Error in path efficiency metric') bins = np.linspace(50, 100, 25) hist, bins, patches = plt.hist(efficiencies, bins, color='pink', density=True, alpha=0.7) # hist, bin_edges = np.histogram(efficiencies, bins, density=True) plt.title(dataset.title) plt.ylabel('path efficiency') plt.xlabel('percent') plt.xlim([bins[0], bins[-1]]) plt.ylim([0, 0.5]) return hist
def load_forking_path(path, **kwargs): traj_dataset = TrajDataset() raw_data = [] with open(path, 'r') as json_file: json_content = json_file.read() annots_list = json.loads(json_content) for annot_dict in annots_list: scene_name = annot_dict['scenename'] x_agents = annot_dict['x_agents'] ped_controls = annot_dict['ped_controls'] print(scene_name) for frame_id, control_data in ped_controls.items(): for person_id, _, xyz, direction_vector, speed, time_elasped, is_static in sorted( control_data): print(frame_id, person_id, xyz[:2]) raw_data.append([int(frame_id), int(person_id), *xyz[:2]]) dummy = 1 break raw_dataset = pd.DataFrame( raw_data, columns=["frame_id", "agent_id", "pos_x", "pos_y"]) raw_dataset = raw_dataset.sort_values(by='frame_id', ascending=True).reset_index() agents = raw_dataset.groupby("agent_id").apply(list) agents = [g for gname, g in raw_dataset.groupby("agent_id")] return traj_dataset
def load_town_center(path, **kwargs): # Construct dataset traj_dataset = TrajDataset() # Note: we assume here that the path that is passed is the one to the tracks CSV. # Read the tracks raw_dataset = pd.read_csv(path, sep=",", header=0, names=["personNumber", "frameNumber", "headValid", "bodyValid", "headLeft", "headTop", "headRight", "headBottom", "bodyLeft", "bodyTop", "bodyRight", "bodyBottom"]) # Get bottom (feet) of bounding boxes raw_dataset["body_x"] = (raw_dataset["bodyLeft"] + raw_dataset["bodyRight"]) / 2.0 raw_dataset["body_y"] = raw_dataset["bodyBottom"] raw_dataset["head_x"] = (raw_dataset["headLeft"] + raw_dataset["headRight"]) / 2.0 raw_dataset["head_y"] = (raw_dataset["headTop"] + raw_dataset["headBottom"]) / 2.0 # Required information raw_dataset["label"] = "pedestrian" # Read camera calibration calibration_path = kwargs.get('calib_path', 'none') rvec, tvec, cameraMatrix, distCoeffs =\ read_projection_parameters(calibration_path) # Obtain real world coordinates from image pts = np.array([raw_dataset["body_x"], raw_dataset["body_y"]]).T objPts = obtainObjectPoints(pts, rvec, tvec, cameraMatrix, distCoeffs) # Add object points to raw dataset raw_dataset['pos_x'] = objPts[:, 0] raw_dataset['pos_y'] = objPts[:, 1] raw_dataset['pos_z'] = objPts[:, 2] # Remove invalid body bounding boxes raw_dataset = raw_dataset[raw_dataset.bodyValid == 1] # Copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frameNumber", "personNumber", "pos_x", "pos_y"]] # FixMe: for debug traj_dataset.data[["body_x", "body_y"]] = \ raw_dataset[["body_x", "body_y"]].astype(int) # Recording information traj_dataset.title = kwargs.get('title', "Town-Center") traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', 25) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def local_density(all_frames,trajlets,name): #define local density function #for all pedestrians at that time, find its distance to NN distNN = [] dens_t = [] a=1 new_frames = [] for frame in all_frames: if len(frame)>1: #find pairwise min distance distNN.append([]) dens_t.append([]) dist = squareform(pdist(frame[['pos_x','pos_y']].values)) pair_dist = [] for pi in dist: pair_dist.append(np.array(pi)) min_pi = [j for j in pi if j>0.01] if len(min_pi) == 0: min_dist = 0.01 else: min_dist = np.min(min_pi) distNN[-1].append(min_dist) #calculate local density for agent pj for pj in range(len(dist)): dens_t_i = 1/(2*np.pi)*np.sum(1/((a*np.array(distNN[-1]))**2)*np.exp(-np.divide((pair_dist[pj]**2),(2*(a*np.array(distNN[-1]))**2)))) dens_t[-1].append(dens_t_i) frame.loc[frame.index[pj],'p_local'] = dens_t_i new_frames.append(frame) new_frames = pd.concat(new_frames) new_traj = TrajDataset() new_traj.data = new_frames trajs = new_traj.get_trajectories(label="pedestrian") trajlets[name] = split_trajectories(trajs, to_numpy=False) #average local density for each trajlet avg_traj_plocal=[] for trajlet in trajlets[name]: avg_traj_plocal.append(np.max(trajlet['p_local'])) return avg_traj_plocal
def ttc(all_frames, name, trajlets): all_ttc = [] Rp = 0.33 #assume pedestrians radius is 0.33 new_frames = [] for frame in all_frames: frame.reset_index(inplace=True) #if there is only one pedestrian at that time, or encounter invalid vel value if len(frame.index) < 2 or frame['vel_x'].isnull().values.any( ) or frame['vel_y'].isnull().values.any(): continue #calculate ttc for each pair x_4d = np.stack((frame.pos_x.values, frame.pos_y.values, frame.vel_x.values, frame.vel_y.values), axis=1) DCA, TTCA = DCA_MTX(x_4d) for i in range(len(TTCA)): #find out ttc of one agent ttc = [ TTCA[i][j] for j in range(len(TTCA[i])) if DCA[i][j] < 2 * Rp and TTCA[i][j] > 0 ] #find out min ttc for one agent if len(ttc) > 0: min_ttc = np.min(ttc) frame.loc[i, 'ttc'] = min_ttc min_dca = np.min([j for j in DCA[i] if j > 0]) frame.loc[i, 'dca'] = min_dca new_frames.append(frame) new_frames = pd.concat(new_frames) new_traj = TrajDataset() new_traj.data = new_frames trajs = new_traj.get_trajectories(label="pedestrian") trajlets[name] = split_trajectories(trajs, to_numpy=False) #average local density o each trajlet avg_traj_ttc = [] avg_traj_dca = [] for trajlet in trajlets[name]: avg_traj_ttc.append(np.min(trajlet['ttc'].dropna())) #min of min avg_traj_dca.append(np.min(trajlet['dca'].dropna())) #min of min return avg_traj_ttc, avg_traj_dca
def load_kitti(path, **kwargs): traj_dataset = TrajDataset() traj_dataset.title = "KITTI" track_files_list = sorted(glob.glob(path + "/label/*.txt")) calib_files_list = sorted(glob.glob(path + "/calib/*.txt")) imu_files_list = sorted(glob.glob(path + "/oxts/*.txt")) #load track data, calibration data, IMU data from all scenes track_rawData = loadTrack(track_files_list) #(left camera coordinate) calib_rawData = loadCalib(calib_files_list) imu_rawData = loadIMU(imu_files_list) #convert track data to world coordinate (imu coordinate in the first frame of that scene) track_world_pos = track_camToworld(track_rawData, calib_rawData, imu_rawData) track_rawData = pd.concat(track_rawData) track_rawData.reset_index(inplace=True, drop=True) traj_dataset.data[["frame_id", "agent_id", "label", "scene_id"]] = track_rawData[[ "frame", "agent_id", "type", "scene" ]] traj_dataset.data[["pos_x", "pos_y", "pos_z"]] = track_world_pos[["pos_x", "pos_y", "pos_z"]] # post-process. For KITTI, raw data do not include velocity, velocity info is postprocessed fps = kwargs.get('fps', 10) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def load_cff(path, **kwargs): traj_dataset = TrajDataset() # read from csv => python str # sample line: 2012-09-18T06:25:00:036;PIE;17144;50515;1 # columns = ["Year", "Month", "Day", "Hour", "min", "sec", "msec", "place", "x_mm", "y_mm", "agent_id"] with open(path, 'r') as inp_file: file_content = inp_file.read() file_content = file_content.replace('T', '-').replace(':', '-').replace( ';', '-').replace('\n', '-') segments = file_content.split('-') segments.remove('') year = np.array(segments[0::11], dtype=int) month = np.array(segments[1::11], dtype=int) day = np.array(segments[2::11], dtype=int) hour = np.array(segments[3::11], dtype=int) minute = np.array(segments[4::11], dtype=int) second = np.array(segments[5::11], dtype=int) milli_sec = np.array(segments[6::11], dtype=int) place = np.array(segments[7::11], dtype=str) x_mm = np.array(segments[8::11], dtype=float) y_mm = np.array(segments[9::11], dtype=float) agent_id = np.array(segments[10::11], dtype=int) # skip year and month timestamp = ( (day * 24 + hour) * 60 + minute) * 60 + second + milli_sec / 1000. fps = 10 traj_dataset.title = kwargs.get('title', "Train Terminal") raw_dataset = pd.DataFrame({ "timestamp": timestamp, "frame_id": (timestamp * fps).astype(int), "agent_id": agent_id, "pos_x": x_mm / 1000., "pos_y": y_mm / 1000., }) # raw_dataset["scene_id"] = place scene_id = kwargs.get('scene_id', 0) raw_dataset["scene_id"] = scene_id # copy columns traj_dataset.data[["scene_id", "timestamp", "frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["scene_id", "timestamp", "frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["label"] = "pedestrian" # post-process sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', True) # use kalman smoother by default traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def load_trajnet(path, **kwargs): traj_dataset = TrajDataset() traj_dataset.title = kwargs.get('title', "TrajNet") csv_columns = ["frame_id", "agent_id", "pos_x", "pos_y"] # read from csv => fill traj raw_dataset = pd.read_csv(path, sep=" ", header=None, names=csv_columns) raw_dataset.replace('?', np.nan, inplace=True) raw_dataset.dropna(inplace=True) # FIXME: in the cases you load more than one file into a TrajDataset Object # rearrange columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["scene_id"] = kwargs.get("scene_id", 0) # calculate velocities + perform some checks if 'stanford' in path: fps = 30 elif 'crowd' in path or 'biwi' in path: fps = 16 else: fps = 7 sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def run(): traj_dataset = TrajDataset() traj_dataset.add_agent(12, 10, 1., 0., 125.) print("\n\n-----------------------------\nRunning test crowd\n-----------------------------") # f0 = frame(0) # # print("\n1:\n",f0.get_frame()) # # f0.add_agent(12,1,0,125) # f0.add_agent(15,10,52,15) # # print("\n2:\n",f0.get_frame()) # # f0.set_agents_list_size(1) # f0.add_agent(132,15,25,1225) # # print("\n3:\n",f0.get_frame()) # # f0.reset_frame() # # print("\n4:\n",f0.get_frame()) # # t = TrajectoryDataset() # # for i in range(0,3): # f = frame(i+5) # f.add_agent(15,random(),random(),random()) # f.add_agent(17,random(),random(),random()) # t.add_frame(f) # # traj = t.get_trajectories() # print("Trajectory:\n1:\n",traj) # t.reset_trajectory() # traj = t.get_trajectories() # print("\n3: reset \n",traj) print("\n\n-----------------------------\nTest crowd done\n-----------------------------")
def num_trajlets(dataset: TrajDataset, length=4.8, overlap=2): trajs = dataset.get_trajectories(label="pedestrian") trajlets = split_trajectories(trajs, length, overlap, static_filter_thresh=0.) non_static_trajlets = split_trajectories(trajs, length, overlap, static_filter_thresh=1.) return len(trajlets), len(non_static_trajlets)
def load_wildtrack(path: str, **kwargs): """ :param path: path to annotations dir :param kwargs: :return: """ traj_dataset = TrajDataset() files_list = sorted(glob.glob(path + "/*.json")) raw_data = [] for file_name in files_list: frame_id = int(os.path.basename(file_name).replace('.json', '')) with open(file_name, 'r') as json_file: json_content = json_file.read() annots_list = json.loads(json_content) for annot in annots_list: person_id = annot["personID"] position_id = annot["positionID"] X = -3.0 + 0.025 * (position_id % 480) Y = -9.0 + 0.025 * (position_id / 480) raw_data.append([frame_id, person_id, X, Y]) csv_columns = ["frame_id", "agent_id", "pos_x", "pos_y"] raw_dataset = pd.DataFrame(np.array(raw_data), columns=csv_columns) traj_dataset.title = kwargs.get('title', "Grand Central") # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', 10) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def load_eth(path, **kwargs): traj_dataset = TrajDataset() csv_columns = [ "frame_id", "agent_id", "pos_x", "pos_z", "pos_y", "vel_x", "vel_z", "vel_y" ] # read from csv => fill traj table raw_dataset = pd.read_csv(path, sep=r"\s+", header=None, names=csv_columns) traj_dataset.title = kwargs.get('title', "no_title") # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y", "vel_x", "vel_y" ]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y", "vel_x", "vel_y" ]] traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', -1) if fps < 0: d_frame = np.diff(pd.unique(raw_dataset["frame_id"])) fps = d_frame[ 0] * 2.5 # 2.5 is the common annotation fps for all (ETH+UCY) datasets sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def density_vanilla_plot( dataset: TrajDataset ): # over observed space of the dataset ([minx,maxx], [miny, maxy]) space = (dataset.bbox['x']['max'] - dataset.bbox['x']['min']) * \ (dataset.bbox['y']['max'] - dataset.bbox['y']['min']) density_t = [] frames = dataset.get_frames() for frame in frames: density_t.append(len(frame) / space) bins = np.linspace(0, 1, 40) hist, bins, patches = plt.hist(density_t, bins=bins, color='red', density=True, alpha=0.7) plt.title(dataset.title) plt.ylabel('distribution of density') plt.xlabel('Person per m^2')
def speed_plot(dataset: TrajDataset): trajectories = dataset.get_trajectories() speeds = [] for traj in trajectories: speeds_i = speed(traj) speeds.extend(speeds_i) bins = np.linspace(0, 2.5, 25) hist, bins, patches = plt.hist(speeds, bins, color='blue', density=True, alpha=0.7) # hist, bin_edges = np.histogram(ped_speeds, bins, density=True) plt.suptitle(dataset.title) plt.ylabel('histogram of speeds') plt.xlabel('m/s') plt.xlim([bins[0], bins[-1]]) plt.ylim([0, 6]) return hist
def load_sdd(path, **kwargs): sdd_dataset = TrajDataset() sdd_dataset.title = "SDD" csv_columns = [ "agent_id", "x_min", "y_min", "x_max", "y_max", "frame_id", "lost", "occluded", "generated", "label" ] scale = kwargs.get("scale", 1) # read from csv => fill traj table raw_dataset = pd.read_csv(path, sep=" ", header=None, names=csv_columns) raw_dataset["pos_x"] = scale * (raw_dataset["x_min"] + raw_dataset["x_max"]) / 2 raw_dataset["pos_y"] = scale * (raw_dataset["y_min"] + raw_dataset["y_max"]) / 2 drop_lost_frames = kwargs.get('drop_lost_frames', False) if drop_lost_frames: raw_dataset = raw_dataset.loc[raw_dataset["lost"] != 1] # copy columns sdd_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y", # "x_min", "y_min", "x_max", "y_max", "label", "lost", "occluded", "generated"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y", # "x_min", "y_min", "x_max", "y_max", "label", "lost", "occluded", "generated"]] sdd_dataset.data["scene_id"] = kwargs.get("scene_id", 0) # calculate velocities + perform some checks fps = 30 sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) sdd_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return sdd_dataset
def pcf_plot(dataset: TrajDataset): frames = dataset.get_frames() # calc pcf on a dataset pcf_accum = [] pcf_range = np.arange( 0.2, # starting radius 8, # end radius 0.2) # step size for frame in frames: pcf_values_t = pcf(frame[['pos_x', 'pos_y', 'pos_z']], list(pcf_range), sigma=0.25) if not len(pcf_accum): pcf_accum = pcf_values_t else: pcf_accum += pcf_values_t avg_pcf = pcf_accum / len(frames) plt.title(dataset.title) plt.ylabel('PCF') plt.xlabel('meter') plt.plot(avg_pcf, color='purple')
def acceleration_plot(dataset: TrajDataset): trajectories = dataset.get_trajectories() accelerations = [] for traj in trajectories: if len(traj) < 2: continue accelerations_i = acceleration(traj) accelerations.extend(accelerations_i) bins = np.linspace(-2.5, 2.5, 100) # hist, bin_edges = np.histogram(ped_accelerations, bins, density=True) hist, bins, patches = plt.hist(accelerations, bins, color='red', density=True, alpha=0.7) plt.title(dataset.title) plt.ylabel('histogram of accelerations') plt.xlabel('m/s^2') plt.xlim([-2.5, 2.5]) plt.ylim([0, 5]) return hist
def load_edinburgh(path, **kwargs): traj_dataset = TrajDataset() traj_dataset.title = "Edinburgh" if os.path.isdir(path): files_list = sorted(glob.glob(path + "/*.txt")) elif os.path.exists(path): files_list = [path] else: raise ValueError("loadEdinburgh: input file is invalid") csv_columns = ['centre_x', 'centre_y', 'frame', 'agent_id', 'length'] # read from csv => fill traj table raw_dataset = [] scene = [] last_scene_frame = 0 new_id = 0 scale = 0.0247 # load data from all files for file in files_list: data = pd.read_csv(file, sep="\n|=", header=None, index_col=None) data.reset_index(inplace=True) properties = data[data['index'].str.startswith('Properties')] data = data[data['index'].str.startswith('TRACK')] #reconstruct the data in arrays track_data = [] print("reading:" + str(file)) for row in range(len(data)): one_prop = properties.iloc[row, 1].split(";") one_prop.pop() one_prop = [ ast.literal_eval(i.replace(' ', ',')) for i in one_prop ] track_length = one_prop[0][0] one_track = data.iloc[row, 1].split(";") one_track.pop() one_track[0] = one_track[0].replace('[[', '[') one_track[-1] = one_track[-1].replace(']]', ']') one_track = np.array([ ast.literal_eval(i.replace(' [', '[').replace(' ', ',')) for i in one_track ]) one_track = np.c_[one_track, np.ones(one_track.shape[0], dtype=int) * row, track_length * np.ones(one_track.shape[0], dtype=int)] track_data.extend(one_track) #clear repeated trajectories track_data_pd = pd.DataFrame(data=np.array(track_data), columns=csv_columns) clean_track = [] for i in tqdm(track_data_pd.groupby('agent_id')): i[1].drop_duplicates(subset="frame", keep='first', inplace=True) # clean repeated trajectory for the same agent for j in i[1].groupby(['frame', 'centre_x', 'centre_y']): j[1].drop_duplicates(subset="frame", keep='first', inplace=True) clean_track.append(j[1]) clean_track = np.concatenate(clean_track) #re-id uid = np.unique(clean_track[:, 3]) ##added!! copy_id = deepcopy(clean_track[:, 3]) for oneid in uid: oneid_idx = [idx for idx, x in enumerate(copy_id) if x == oneid] for j in oneid_idx: clean_track[j, 3] = new_id new_id += 1 scene.extend([files_list.index(file)] * len(clean_track)) raw_dataset.extend(clean_track.tolist()) raw_dataset = pd.DataFrame(np.array(raw_dataset), columns=csv_columns) raw_dataset.reset_index(inplace=True, drop=True) #find homog matrix H = get_homog() #apply H matrix to the image point img_data = raw_dataset[["centre_x", "centre_y"]].values world_data = [] for row in img_data: augImg_data = np.c_[[row], np.array([1])] world_data.append(np.matmul(H, augImg_data.reshape(3, 1)).tolist()[:2]) raw_dataset["centre_x"] = np.array(world_data)[:, 0] raw_dataset["centre_y"] = np.array(world_data)[:, 1] traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = raw_dataset[[ "frame", "agent_id", "centre_x", "centre_y" ]] traj_dataset.data["scene_id"] = kwargs.get("scene_id", scene) traj_dataset.data["label"] = "pedestrian" traj_dataset.title = kwargs.get('title', "Edinburgh") # post-process. For Edinburgh, raw data do not include velocity, velocity info is postprocessed fps = kwargs.get('fps', 9) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) print("finish") return traj_dataset
def load_chaos(path, separator, **kwargs): traj_dataset = TrajDataset() # TODO # ChAOS Style: 1 file per agent, pos_x, pos_y print("\nLoad Chaos style: not implemented yet\n") return traj_dataset
def load_ind(path, **kwargs): traj_dataset = TrajDataset() # Note: we assume here that the path that is passed is the one to the tracks CSV. # Read the tracks raw_dataset = pd.read_csv( path, sep=",", header=0, names=[ "recordingId", "trackId", "frame", "trackLifetime", "xCenter", "yCenter", "heading", "width", "length", "xVelocity", "yVelocity", "xAcceleration", "yAcceleration", "lonVelocity", "latVelocity", "lonAcceleration", "latAcceleration" ]) # Read the recording data data_path = pathlib.Path(path) datadir_path = data_path.parent recording_path = str(datadir_path) + '/{:02d}_recordingMeta.csv'.format( raw_dataset['recordingId'][0]) recording_data = pd.read_csv(recording_path, sep=",", header=0, names=[ "recordingId", "locationId", "frameRate", "speedLimit", "weekday", "startTime", "duration", "numTracks", "numVehicles", "numVRUs", "latLocation", "lonLocation", "xUtmOrigin", "yUtmOrigin", "orthoPxToMeter" ]) traj_dataset.title = kwargs.get('title', "inD") # Read the meta-tracks data tracks_path = str(datadir_path) + '/{:02d}_tracksMeta.csv'.format( raw_dataset['recordingId'][0]) tracks_data = pd.read_csv(tracks_path, sep=",", header=0, names=[ "recordingId", "trackId", "initialFrame", "finalFrame", "numFrames", "width", "length", "class" ]) # Get the ids of pedestrians only ped_ids = tracks_data[tracks_data["class"] == "pedestrian"]["trackId"].values raw_dataset = raw_dataset[raw_dataset['trackId'].isin(ped_ids)] # Copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y", "vel_x", "vel_y"]] = \ raw_dataset[["frame", "trackId", "xCenter", "yCenter", "xVelocity", "yVelocity"]] traj_dataset.data["label"] = "pedestrian" scene_id = kwargs.get("scene_id", recording_data["locationId"][0]) traj_dataset.data["scene_id"] = scene_id # print("location_id = ", recording_data["locationId"][0]) # post-process fps = int(recording_data["frameRate"][0]) # fps = 25 sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def grouping(dataset: TrajDataset): trajs = dataset.get_trajectories("pedestrian") trajlets = split_trajectories(trajs) for trajlet in trajlets: pass return
def load_pets(path, **kwargs): """ :param path: address of annotation file :param kwargs: :param calib_path: address of calibration file :return: TrajectoryDataset object """ traj_dataset = TrajDataset() annot_xtree = et.parse(path) annot_xroot = annot_xtree.getroot() # dataset cp, cc = None, None # calibration parameters # load calibration calib_path = kwargs.get('calib_path', "") if calib_path: cp = CameraParameters() cc = CalibrationConstants() calib_xtree = et.parse(calib_path) calib_xroot = calib_xtree.getroot() # Camera geometry_node = calib_xroot.find("Geometry") width = int(geometry_node.attrib["width"]) height = int(geometry_node.attrib["height"]) cp.Ncx = float(geometry_node.attrib["ncx"]) cp.Nfx = float(geometry_node.attrib["nfx"]) cp.dx = float(geometry_node.attrib["dx"]) cp.dy = float(geometry_node.attrib["dy"]) cp.dpx = float(geometry_node.attrib["dpx"]) cp.dpy = float(geometry_node.attrib["dpy"]) intrinsic_node = calib_xroot.find("Intrinsic") cc.f = float(intrinsic_node.attrib["focal"]) cc.kappa1 = float( intrinsic_node.attrib["kappa1"]) # 1st order radial distortion cp.Cx = float(intrinsic_node.attrib["cx"]) cp.Cy = float(intrinsic_node.attrib["cy"]) cp.sx = float(intrinsic_node.attrib["sx"]) extrinsic_node = calib_xroot.find("Extrinsic") cc.Tx = float(extrinsic_node.attrib["tx"]) cc.Ty = float(extrinsic_node.attrib["ty"]) cc.Tz = float(extrinsic_node.attrib["tz"]) cc.Rx = float(extrinsic_node.attrib["rx"]) cc.Ry = float(extrinsic_node.attrib["ry"]) cc.Rz = float(extrinsic_node.attrib["rz"]) cc.calc_rr() # Calculate Rotation Matrix loaded_data = [] # frame_id, agent_id, pos_x, pos_y, xc, yc, h, w for frame_node in annot_xroot: objectlist_node = frame_node.find("objectlist") # .text object_nodes = objectlist_node.findall("object") frame_id = int(frame_node.attrib.get("number")) for obj_node in object_nodes: agent_id = obj_node.attrib["id"] box_node = obj_node.find("box") xc = float(box_node.attrib["xc"]) yc = float(box_node.attrib["yc"]) h = float(box_node.attrib["h"]) w = float(box_node.attrib["w"]) x_ground = xc y_ground = yc + h / 2 if cp: pos_x, pos_y = image_coord_to_world_coord( x_ground, y_ground, 0, cp, cc) else: pos_x, pos_y = np.nan, np.nan loaded_data.append([ frame_id, agent_id, pos_x / 1000., pos_y / 1000., xc, yc, h, w ]) data_columns = [ "frame_id", "agent_id", "pos_x", "pos_y", "xc", "yc", "h", "w" ] raw_dataset = pd.DataFrame(np.array(loaded_data), columns=data_columns) traj_dataset.title = kwargs.get('title', "PETS") # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" # post-process fps = kwargs.get('fps', 7) sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) return traj_dataset
def get_datasets(opentraj_root, dataset_names): datasets = {} # Make a temp dir to store and load trajdatasets (no postprocess anymore) trajdataset_dir = os.path.join(opentraj_root, 'trajdatasets__temp') if not os.path.exists(trajdataset_dir): os.makedirs(trajdataset_dir) for dataset_name in dataset_names: dataset_h5_file = os.path.join(trajdataset_dir, dataset_name + '.h5') if os.path.exists(dataset_h5_file): datasets[dataset_name] = TrajDataset() datasets[dataset_name].data = pd.read_pickle(dataset_h5_file) datasets[dataset_name].title = dataset_name print("loading dataset from pre-processed file: ", dataset_h5_file) continue print("Loading dataset:", dataset_name) # ========== ETH ============== if 'eth-univ' == dataset_name.lower(): eth_univ_root = os.path.join(opentraj_root, 'datasets/ETH/seq_eth/obsmat.txt') datasets[dataset_name] = load_eth(eth_univ_root, title=dataset_name, scene_id='Univ', use_kalman=True) elif 'eth-hotel' == dataset_name.lower(): eth_hotel_root = os.path.join(opentraj_root, 'datasets/ETH/seq_hotel/obsmat.txt') datasets[dataset_name] = load_eth(eth_hotel_root, title=dataset_name, scene_id='Hotel') # ****************************** # ========== UCY ============== elif 'ucy-zara' == dataset_name.lower(): # all 3 zara sequences zara01_dir = os.path.join(opentraj_root, 'datasets/UCY/zara01') zara02_dir = os.path.join(opentraj_root, 'datasets/UCY/zara02') zara03_dir = os.path.join(opentraj_root, 'datasets/UCY/zara03') zara_01_ds = load_crowds(zara01_dir + '/annotation.vsp', homog_file=zara01_dir + '/H.txt', scene_id='1', use_kalman=True) zara_02_ds = load_crowds(zara02_dir + '/annotation.vsp', homog_file=zara02_dir + '/H.txt', scene_id='2', use_kalman=True) zara_03_ds = load_crowds(zara03_dir + '/annotation.vsp', homog_file=zara03_dir + '/H.txt', scene_id='3', use_kalman=True) datasets[dataset_name] = merge_datasets([zara_01_ds, zara_02_ds, zara_03_ds], dataset_name) elif 'ucy-univ' == dataset_name.lower(): # all 3 sequences st001_dir = os.path.join(opentraj_root, 'datasets/UCY/students01') st003_dir = os.path.join(opentraj_root, 'datasets/UCY/students03') uni_ex_dir = os.path.join(opentraj_root, 'datasets/UCY/uni_examples') #st001_ds = load_Crowds(st001_dir + '/students001.txt',homog_file=st001_dir + '/H.txt',scene_id='1',use_kalman=True) st001_ds = load_crowds(st001_dir + '/annotation.vsp', homog_file=st003_dir + '/H.txt', scene_id='1', use_kalman=True) st003_ds = load_crowds(st003_dir + '/annotation.vsp', homog_file=st003_dir + '/H.txt', scene_id='3', use_kalman=True) uni_ex_ds = load_crowds(uni_ex_dir + '/annotation.vsp', homog_file=st003_dir + '/H.txt', scene_id='ex', use_kalman=True) datasets[dataset_name] = merge_datasets([st001_ds, st003_ds, uni_ex_ds], dataset_name) elif 'ucy-zara1' == dataset_name.lower(): zara01_root = os.path.join(opentraj_root, 'datasets/UCY/zara01/obsmat.txt') datasets[dataset_name] = load_eth(zara01_root, title=dataset_name) elif 'ucy-zara2' == dataset_name.lower(): zara02_root = os.path.join(opentraj_root, 'datasets/UCY/zara02/obsmat.txt') datasets[dataset_name] = load_eth(zara02_root, title=dataset_name) elif 'ucy-univ3' == dataset_name.lower(): students03_root = os.path.join(opentraj_root, 'datasets/UCY/students03/obsmat.txt') datasets[dataset_name] = load_eth(students03_root, title=dataset_name) # ****************************** # ========== HERMES ============== elif 'bn' in dataset_name.lower().split('-'): [_, exp_flow, cor_size] = dataset_name.split('-') if exp_flow == '1d' and cor_size == 'w180': # 'Bottleneck-udf-180' bottleneck_path = os.path.join(opentraj_root, 'datasets/HERMES/Corridor-1D/uo-180-180-120.txt') elif exp_flow == '2d' and cor_size == 'w160': # 'Bottleneck-bdf-160' bottleneck_path = os.path.join(opentraj_root, "datasets/HERMES/Corridor-2D/bo-360-160-160.txt") else: "Unknown Bottleneck dataset!" continue datasets[dataset_name] = load_bottleneck(bottleneck_path, sampling_rate=6, use_kalman=True, title=dataset_name) # ****************************** # ========== PETS ============== elif 'pets-s2l1' == dataset_name.lower(): pets_root = os.path.join(opentraj_root, 'datasets/PETS-2009/data') datasets[dataset_name] = load_pets(os.path.join(pets_root, 'annotations/PETS2009-S2L1.xml'), #Pat:was PETS2009-S2L2 calib_path=os.path.join(pets_root, 'calibration/View_001.xml'), sampling_rate=2, title=dataset_name) # ****************************** # ========== GC ============== elif 'gc' == dataset_name.lower(): gc_root = os.path.join(opentraj_root, 'datasets/GC/Annotation') datasets[dataset_name] = load_gcs(gc_root, world_coord=True, title=dataset_name, use_kalman=True ) # ****************************** # ========== InD ============== elif 'ind-1' == dataset_name.lower(): ind_root = os.path.join(opentraj_root, 'datasets/InD/inD-dataset-v1.0/data') file_ids = range(7, 17 + 1) # location_id = 1 ind_1_datasets = [] for id in file_ids: dataset_i = load_ind(os.path.join(ind_root, '%02d_tracks.csv' % id), scene_id='1-%02d' %id, sampling_rate=10, use_kalman=True) ind_1_datasets.append(dataset_i) datasets[dataset_name] = merge_datasets(ind_1_datasets, new_title=dataset_name) elif 'ind-2' == dataset_name.lower(): ind_root = os.path.join(opentraj_root, 'datasets/InD/inD-dataset-v1.0/data') file_ids = range(18, 29 + 1) # location_id = 1 ind_2_datasets = [] for id in file_ids: dataset_i = load_ind(os.path.join(ind_root, '%02d_tracks.csv' % id), scene_id='1-%02d' % id, sampling_rate=10, use_kalman=True) ind_2_datasets.append(dataset_i) datasets[dataset_name] = merge_datasets(ind_2_datasets, new_title=dataset_name) elif 'ind-3' == dataset_name.lower(): ind_root = os.path.join(opentraj_root, 'datasets/InD/inD-dataset-v1.0/data') file_ids = range(30, 32 + 1) # location_id = 1 ind_3_datasets = [] for id in file_ids: dataset_i = load_ind(os.path.join(ind_root, '%02d_tracks.csv' % id), scene_id='1-%02d' % id, sampling_rate=10, use_kalman=True) ind_3_datasets.append(dataset_i) datasets[dataset_name] = merge_datasets(ind_3_datasets, new_title=dataset_name) elif 'ind-4' == dataset_name.lower(): ind_root = os.path.join(opentraj_root, 'datasets/InD/inD-dataset-v1.0/data') file_ids = range(0, 6 + 1) # location_id = 1 ind_4_datasets = [] for id in file_ids: dataset_i = load_ind(os.path.join(ind_root, '%02d_tracks.csv' % id), scene_id='1-%02d' % id, sampling_rate=10, use_kalman=True) ind_4_datasets.append(dataset_i) datasets[dataset_name] = merge_datasets(ind_4_datasets, new_title=dataset_name) # ****************************** # ========== KITTI ============== elif 'kitti' == dataset_name.lower(): kitti_root = os.path.join(opentraj_root, 'datasets/KITTI/data') datasets[dataset_name] = load_kitti(kitti_root, title=dataset_name, use_kalman=True, sampling_rate=1) # FixMe: apparently original_fps = 2.5 # ****************************** # ========== L-CAS ============== elif 'lcas-minerva' == dataset_name.lower(): lcas_root = os.path.join(opentraj_root, 'datasets/L-CAS/data') datasets[dataset_name] = load_lcas(lcas_root, title=dataset_name, use_kalman=True, sampling_rate=1) # FixMe: apparently original_fps = 2.5 # ****************************** # ========== Wild-Track ============== elif 'wildtrack' == dataset_name.lower(): wildtrack_root = os.path.join(opentraj_root, 'datasets/Wild-Track/annotations_positions') datasets[dataset_name] = load_wildtrack(wildtrack_root, title=dataset_name, use_kalman=True, sampling_rate=1) # original_annot_framerate=2 # ****************************** # ========== Edinburgh ============== elif 'edinburgh' in dataset_name.lower(): edinburgh_dir = os.path.join(opentraj_root, 'datasets/Edinburgh/annotations') if 'edinburgh' == dataset_name.lower(): # all files # edinburgh_path = edinburgh_dir # select 1-10 Sep Ed_selected_days = ['01Sep', '02Sep', '04Sep', '05Sep', '06Sep', '10Sep'] partial_ds = [] for selected_day in Ed_selected_days: edinburgh_path = os.path.join(edinburgh_dir, 'tracks.%s.txt' % selected_day) partial_ds.append(load_edinburgh(edinburgh_path, title=dataset_name, use_kalman=True, scene_id=selected_day, sampling_rate=4) # original_framerate=9 ) merge_datasets(partial_ds) else: seq_date = dataset_name.split('-')[1] edinburgh_path = os.path.join(edinburgh_dir, 'tracks.%s.txt' %seq_date) datasets[dataset_name] = load_edinburgh(edinburgh_path, title=dataset_name, use_kalman=True, sampling_rate=4) # original_framerate=9 # ****************************** # ========== Town-Center ============== elif 'towncenter' == dataset_name.lower(): towncenter_root = os.path.join(opentraj_root, 'datasets/Town-Center') # FixMe: might need Kalman Smoother datasets[dataset_name] = load_town_center(towncenter_root + '/TownCentre-groundtruth-top.txt', calib_path=towncenter_root + '/TownCentre-calibration-ci.txt', title=dataset_name, use_kalman=True, sampling_rate=10) # original_framerate=25 # ****************************** # ========== SDD ============== elif 'sdd-' in dataset_name.lower(): scene_name = dataset_name.split('-')[1] sdd_root = os.path.join(opentraj_root, 'datasets', 'SDD') annot_files_sdd = sorted(glob.glob(sdd_root + '/' + scene_name + "/**/annotations.txt", recursive=True)) sdd_scales_yaml_file = os.path.join(sdd_root, 'estimated_scales.yaml') with open(sdd_scales_yaml_file, 'r') as f: scales_yaml_content = yaml.load(f, Loader=yaml.FullLoader) scene_datasets = [] for file_name in annot_files_sdd: filename_parts = file_name.split('/') scene_name = filename_parts[-3] scene_video_id = filename_parts[-2] scale = scales_yaml_content[scene_name][scene_video_id]['scale'] sdd_dataset_i = load_sdd(file_name, scale=scale, scene_id=scene_name + scene_video_id.replace('video', ''), drop_lost_frames=False, use_kalman=True, sampling_rate=12) # original_framerate=30 scene_datasets.append(sdd_dataset_i) scene_dataset = merge_datasets(scene_datasets, dataset_name) datasets[dataset_name] = scene_dataset # ****************************** else: print("Error! invalid dataset name:", dataset_name) # save to h5 file datasets[dataset_name].data.to_pickle(dataset_h5_file) print("saving dataset into pre-processed file: ", dataset_h5_file) return datasets
def load_gcs(path, **kwargs): traj_dataset = TrajDataset() raw_dataset = pd.DataFrame() file_list = sorted(os.listdir(path)) raw_data_list = [] # the data to be converted into Pandas DataFrame selected_frames = kwargs.get("frames", range(0, 120001)) agent_id_incremental = 0 for annot_file in file_list: annot_file_full_path = os.path.join(path, annot_file) with open(annot_file_full_path, 'r') as f: annot_contents = f.read().split() agent_id = int(annot_file.replace('.txt', '')) agent_id_incremental += 1 last_frame_id = -1 for i in range(len(annot_contents) // 3): py = float(annot_contents[3 * i]) px = float(annot_contents[3 * i + 1]) frame_id = int(annot_contents[3 * i + 2]) # there are trajectory files with non-continuous timestamps # they need to be counted as different agents if last_frame_id > 0 and (frame_id - last_frame_id) > 20: agent_id_incremental += 1 last_frame_id = frame_id if selected_frames.start <= frame_id < selected_frames.stop: raw_data_list.append([frame_id, agent_id_incremental, px, py]) csv_columns = ["frame_id", "agent_id", "pos_x", "pos_y"] raw_data_df = pd.DataFrame(np.stack(raw_data_list), columns=csv_columns) raw_data_df_groupby = raw_data_df.groupby("agent_id") trajs = [g for _, g in raw_data_df_groupby] tr0_ = trajs[0] tr1_ = trajs[1] for ii, tr in enumerate(trajs): if len(tr) < 2: continue # interpolate frames (2x up-sampling) interp_F = np.arange(tr["frame_id"].iloc[0], tr["frame_id"].iloc[-1], 10).astype(int) interp_X = interp1d(tr["frame_id"], tr["pos_x"], kind='linear') interp_X_ = interp_X(interp_F) interp_Y = interp1d(tr["frame_id"], tr["pos_y"], kind='linear') interp_Y_ = interp_Y(interp_F) agent_id = tr["agent_id"].iloc[0] print(agent_id) raw_dataset = raw_dataset.append( pd.DataFrame({ "frame_id": interp_F, "agent_id": agent_id, "pos_x": interp_X_, "pos_y": interp_Y_ })) raw_dataset = raw_dataset.reset_index() # homog = [] # homog_file = kwargs.get("homog_file", "") # if os.path.exists(homog_file): # with open(homog_file) as f: # homog_str = f.read() # homog = np.array(json.loads(homog_str)['homog']) # else: homog = [[4.97412897e-02, -4.24730883e-02, 7.25543911e+01], [1.45017874e-01, -3.35678711e-03, 7.97920970e+00], [1.36068797e-03, -4.98339188e-05, 1.00000000e+00]] # homog = np.eye(3) world_coords = image_to_world(raw_dataset[["pos_x", "pos_y"]].to_numpy(), homog) raw_dataset[["pos_x", "pos_y"]] = pd.DataFrame(world_coords * 0.8) # copy columns traj_dataset.data[["frame_id", "agent_id", "pos_x", "pos_y"]] = \ raw_dataset[["frame_id", "agent_id", "pos_x", "pos_y"]] traj_dataset.title = kwargs.get('title', "Grand Central") traj_dataset.data["scene_id"] = kwargs.get('scene_id', 0) traj_dataset.data["label"] = "pedestrian" fps = kwargs.get('fps', 25) # post-process fps = 30 sampling_rate = kwargs.get('sampling_rate', 1) use_kalman = kwargs.get('use_kalman', False) traj_dataset.postprocess(fps=fps, sampling_rate=sampling_rate, use_kalman=use_kalman) # interpolate = kwargs.get('interpolate', False) # if interpolate: # traj_dataset.interpolate_frames() return traj_dataset