def test_get_segment_between_new_timestamps(self):
df = pd.DataFrame([
{'geometry': Point(0, 0), 't': datetime(2018, 1, 1, 12, 0, 0)},
{'geometry': Point(10, 0), 't': datetime(2018, 1, 1, 12, 10, 0)},
{'geometry': Point(20, 0), 't': datetime(2018, 1, 1, 12, 20, 0)},
{'geometry': Point(30, 0), 't': datetime(2018, 1, 1, 12, 30, 0)}
]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_segment_between(datetime(2018, 1, 1, 12, 5, 0), datetime(2018, 1, 1, 12, 25, 0, 50)).df
expected_result = pd.DataFrame([
{'geometry': Point(10, 0), 't': datetime(2018, 1, 1, 12, 10, 0)},
{'geometry': Point(20, 0), 't': datetime(2018, 1, 1, 12, 20, 0)}
]).set_index('t')
pd.testing.assert_frame_equal(result, expected_result)
def assign_snapshot(self, snapshot):
'''
Assign a single snapshot to the cluster centers
Returns
-------
assignment : int
cluster IDs
distance: float
distance to cluster _generator in measure of the metric (RMSD)
'''
assignments, distances = self.assign(Trajectory([snapshot]))
return assignments[0], distances[0]
def main():
venueData = pd.read_csv("./VenueID_data.csv")
l = Localization(venueData)
trajectorydata = pd.read_csv("./trainTrajectory_final.csv")
#print(trajectorydata["VenueID"].describe())
t = Trajectory(trajectorydata)
usersgroup = l.grouping(groupNum)
testtrajectorydata = pd.read_csv("./testTrajectory_final.csv")
testTrajectory = Trajectory(testtrajectorydata)
models, dics = train(usersgroup=usersgroup, trajectory=t)
for i in range(0, len(models)):
output = open(
'./LocalizationModel/' + str(groupNum) + 'model_state' +
str(states) + "_" + str(i) + '.pkl', 'wb')
s = pickle.dump(models[i], output)
output.close()
for i in range(0, len(models)):
eval_loc_model(testTrajectory=testTrajectory,
model=models[i],
users=usersgroup[i],
dic=dics[i])
def test_nonchronological_input(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 2, 0, 0, 0)
}, {
'geometry': Point(1, 1),
't': datetime(2018, 1, 3, 0, 0, 0)
}, {
'geometry': Point(2, 2),
't': datetime(2018, 1, 1, 0, 0, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
self.assertEqual(datetime(2018, 1, 1), traj.get_start_time())
self.assertEqual(datetime(2018, 1, 3), traj.get_end_time())
self.assertEqual(Point(2, 2), traj.get_start_location())
def test_get_direction(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(-6, 10),
't': datetime(2018, 1, 1, 12, 0, 1)
}, {
'geometry': Point(6, 6),
't': datetime(2018, 1, 1, 12, 0, 2)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_direction()
expected_result = 45
self.assertAlmostEqual(result, expected_result, 1)
def test_endlocation(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 6, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_end_location()
expected_result = Point(10, 0)
self.assertEqual(result, expected_result)
def test_linestring_wkt(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 6, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.to_linestring().wkt
expected_result = "LINESTRING (0 0, 6 0, 10 0)"
self.assertEqual(result, expected_result)
def test_linstring_m_wkt(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(1970, 1, 1, 0, 0, 1)
}, {
'geometry': Point(6, 0),
't': datetime(1970, 1, 1, 0, 0, 2)
}, {
'geometry': Point(10, 0),
't': datetime(1970, 1, 1, 0, 0, 3)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.to_linestringm_wkt()
expected_result = "LINESTRING M (0.0 0.0 1.0, 6.0 0.0 2.0, 10.0 0.0 3.0)"
self.assertEqual(result, expected_result)
def test_get_position_at_existing_timestamp(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 20, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_position_at(datetime(2018, 1, 1, 12, 10, 0))
expected_result = Point(6, 0)
self.assertEqual(result, expected_result)
def run_traclus(trajs, eps, min_lns, min_traj, min_vline, min_prev_dist):
# Cleaning
trajs = [[Point(**pt) for pt in traj] for traj in trajs]
trajs = get_cleaned_trajectories(trajs)
print('Number of trajectories after clean : {}'.format(len(trajs)))
trajs = [Trajectory(traj, tid) for tid, traj in enumerate(trajs)]
# Partitioning
cluster_candidates_tls = []
tls_factory = TrajectoryLineSegmentFactory()
for traj in trajs:
p_indices = call_partition_trajectory(traj.pts)
p_pts = filter_by_indices(p_indices, traj.pts)
traj.p_pts = p_pts
ls_list = get_ls_list(p_pts)
if len(ls_list) <= 0:
raise Exception()
for ls in ls_list:
tls = tls_factory.create(ls, traj.tid)
cluster_candidates_tls.append(tls)
print('Number of segments (cluster candidates) : {}'.format(
len(cluster_candidates_tls)))
# Clustering (DBSCAN)
tls_index = BestAvailableClusterCandidateIndex(cluster_candidates_tls, eps)
tcluster_factory = TrajectoryClusterFactory()
tclusters = dbscan(tls_index, min_lns, tcluster_factory)
print('Number of clusters : {}'.format(len(tclusters)))
# Representative trajectory
rtrajs = []
for tc in tclusters:
if tc.get_num_of_trajs() >= min_traj:
tls_list = tc.get_members()
r_pts = get_rline_pts(tls_list, min_vline, min_prev_dist)
rtraj = RepresentativeTrajectory(r_pts, tc.cid)
rtrajs.append(rtraj)
print('Number of representative trajectories : {}'.format(len(rtrajs)))
result = {
'partitioned_trajectories': trajs,
'clusters': tclusters,
'representative_trajectories': rtrajs
}
return result
def __init__(self, K, T, A):
self.A = A # action scale
self.T = T # time steps per sequence
self.predictor = Predictor(1, 2, 1, self.T)
self.trajectory = Trajectory()
self.trajectory.reset()
self.K = K # K sample action sequences
self.lambd = 1
self.dim_u = 1 # U is theta
# action init
self.U_reset()
self.u_init = np.array([0.0])
self.cost = np.zeros([self.K])
# self.noise = np.random.uniform(-3.14, 3.14, size = (self.K, self.T, self.dim_u))
self.noise = np.zeros([self.K, self.T, self.dim_u])
def main_test():
trajectorydata = pd.read_csv("./trainTrajectory_final.csv")
member = MembershipVector(trajectorydata['UserID'].unique(), GROUP_NUM)
t = Trajectory(trajectorydata)
models = [
hmm.GroupLevelHMM(n_components=N_STATES, init_params='mce')
for i in range(GROUP_NUM)
]
log = open('./logs/log_' + str(datetime.datetime.now()) + '.txt', 'w')
for n in range(30):
print("STAGE : " + str(n + 1))
# iterate through groups
for i in range(0, GROUP_NUM):
print("LEARNING FOR GROUP " + str(i))
data, length, proba = t.getData(i, member)
models[i].set_weights(proba)
models[i].fit(data, length)
print("Grouping...")
# Grouping and update
for i in range(0, GROUP_NUM):
g = Group(hmm=models[i],
membership=member,
trajectory=t,
groupId=i)
member = g.update()
groups = np.zeros(GROUP_NUM)
for i in trajectorydata['UserID']:
groups[member.getProbOfUser(i).argmax()] += 1
print(groups)
eval_log = eval_group_hmms(member, models)
print(eval_log)
log.write(str(eval_log) + "\n")
log.write(str(groups) + "\n\n")
log.close()
for i in range(0, GROUP_NUM):
output = open(
'./models/model_iter_' + str(n) + '_model_' + str(i) + '_' +
str(datetime.datetime.now()) + '.pkl', 'wb')
s = pickle.dump(models[i], output)
output.close()
def test_kinetic_prediction_turning_right(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(20, 0),
't': datetime(2018, 1, 1, 12, 0, 1)
}, {
'geometry': Point(38, -10),
't': datetime(2018, 1, 1, 12, 0, 2)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '4326'})
traj = Trajectory(1, geo_df)
predictor = TrajectoryPredictor(traj)
result = predictor.predict_kinetically(timedelta(seconds=2))
expected_result = Point(68.7, -37.3)
#print("Got {}, expected {}".format(result, expected_result))
self.assertTrue(result.almost_equals(expected_result, 0))
def get_trajectories(self, o,d):
cursor = self.connection.cursor()
cursor.execute('''
SELECT link_ids
FROM experiment2_trajectories
WHERE orig_TAZ = %s AND dest_TAZ = %s
AND commute_direction = %s;
''', (o, d, self.commute_direction))
trajectories = list()
for link_ids in cursor:
filtered = self.link_id_filter(link_ids[0])
if len(filtered) == 0:
continue
t = Trajectory(filtered, (o,d), self.link_geom, self.length_cache)
trajectories.append(t)
return trajectories
def setUp(self):
np.random.seed(2)
n_complexity = 5
self.traj = Trajectory(model='bandlimited')
self.traj.set_n_complexity(n_complexity)
self.traj.set_coeffs(1)
self.anchors = np.random.rand(self.traj.dim,
10) * 10 # between 0 and 10.
self.times = self.traj.get_times(n_samples=200)
self.basis, self.D_gt = get_measurements(self.traj,
self.anchors[:2, :],
times=self.times)
points_gt = self.traj.get_sampling_points(self.times)
self.indices = range(len(self.times))[::self.traj.dim + 1]
self.points_sub = points_gt[:, self.indices]
def test_kinetic_prediction_east_3pt_constant_speed(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 1, 0)
}, {
'geometry': Point(20, 0),
't': datetime(2018, 1, 1, 12, 2, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '4326'})
traj = Trajectory(1, geo_df)
predictor = TrajectoryPredictor(traj)
result = predictor.predict_kinetically(timedelta(minutes=1))
expected_result = Point(30, 0)
#print("Got {}, expected {}".format(result, expected_result))
self.assertTrue(result.almost_equals(expected_result))
def test_clip_two_intersections_with_same_polygon(self):
polygon = Polygon([(5, -5), (7, -5), (7, 12), (5, 12), (5, -5)])
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 6, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 10),
't': datetime(2018, 1, 1, 12, 30, 0)
}, {
'geometry': Point(0, 10),
't': datetime(2018, 1, 1, 13, 0, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
intersections = traj.clip(polygon)
# spatial
result = []
for x in intersections:
result.append(x.to_linestring().wkt)
expected_result = [
"LINESTRING (5 0, 6 0, 7 0)", "LINESTRING (7 10, 5 10)"
]
self.assertEqual(expected_result, result)
# temporal
result = []
for x in intersections:
result.append((x.get_start_time(), x.get_end_time()))
expected_result = [(datetime(2018, 1, 1, 12, 5,
0), datetime(2018, 1, 1, 12, 7, 0)),
(datetime(2018, 1, 1, 12, 39,
0), datetime(2018, 1, 1, 12, 45, 0))]
self.assertEqual(expected_result, result)
# ids
result = []
for x in intersections:
result.append(x.id)
expected_result = ['1_0', '1_1']
self.assertEqual(expected_result, result)
def generate_trajectory(
self,
end_point: np.array,
start_angle: float,
end_angle: float,
primitive_resolution: float,
) -> Union[Trajectory, None]:
"""
Create a trajectory from (0,0, start_angle) to (end_point, end_angle).
The trajectory will consist of a path that contains discrete points
that are spaced primitive_resolution apart.
Args
----
end_point: np.array(2,)
The desired end point of the trajectory
start_angle: float
The start angle of the trajectory in radians
end_angle: float
The end angle of the trajectory in radians
primitive_resolution: float
The spacing between points along the trajectory
Returns
-------
Trajectory or None
If a valid trajectory exists then the Trajectory is returned,
otherwise None
"""
trajectory_params = self._calculate_trajectory_params(
end_point, start_angle, end_angle)
if trajectory_params is None:
return None
logger.debug('Trajectory found')
trajectory_path = self._create_path(trajectory_params,
primitive_resolution)
return Trajectory(trajectory_path, trajectory_params)
def test_get_segment_between_existing_timestamps(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 15, 0)
}, {
'geometry': Point(10, 10),
't': datetime(2018, 1, 1, 12, 30, 0)
}, {
'geometry': Point(0, 10),
't': datetime(2018, 1, 1, 13, 0, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_segment_between(datetime(2018, 1, 1, 12, 10, 0),
datetime(2018, 1, 1, 12, 30, 0)).df
expected_result = pd.DataFrame([{
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 15, 0)
}, {
'geometry': Point(10, 10),
't': datetime(2018, 1, 1, 12, 30, 0)
}]).set_index('t')
pd.testing.assert_frame_equal(result, expected_result)
expected_result = pd.DataFrame([{
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 15, 0)
}, {
'geometry': Point(10, 10),
't': datetime(2018, 1, 1, 12, 30, 1)
}]).set_index('t')
self.assertNotEqual(expected_result.to_dict(), result.to_dict())
def test_get_position_with_invalid_method(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 20, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
try:
result = traj.get_position_at(datetime(2018, 1, 1, 12, 10, 0),
method='xxx')
assert False
except ValueError:
assert True
def __init__(self):
self.on = True
self.motor_on = False
self.save_on = False
self.mode = 0
self.t0 = datetime.datetime.now()
self.t = 0.0
self.t_pre = 0.0
self.freq_imu = 0.0
self.freq_gps = 0.0
self.freq_control = 0.0
self.freq_log = 0.0
self.x = np.zeros(3)
self.v = np.zeros(3)
self.a = np.zeros(3)
self.R = np.identity(3)
self.W = np.zeros(3)
self.x_offset = np.zeros(3)
self.yaw_offset = 0.0
self.g = 9.81
self.ge3 = np.array([0.0, 0.0, self.g])
# Gazebo uses ENU frame, but NED frame is used in FDCL.
self.R_fg = np.array([[1.0, 0.0, 0.0], [0.0, -1.0, 0.0],
[0.0, 0.0, -1.0]])
self.V_R_imu = np.diag([0.01, 0.01, 0.01])
self.V_x_gps = np.diag([0.01, 0.01, 0.01])
self.V_v_gps = np.diag([0.01, 0.01, 0.01])
self.control = Control()
self.control.use_integral = True # Enable integral control
self.estimator = Estimator()
self.trajectory = Trajectory()
self.lock = threading.Lock()
def test_clip_with_numerical_time_issues(self):
xmin, xmax, ymin, ymax = 116.36850352835575, 116.37029459899574, 39.904675309969896, 39.90772814977718
polygon = Polygon([(xmin, ymin), (xmin, ymax), (xmax, ymax),
(xmax, ymin), (xmin, ymin)])
df = pd.DataFrame([{
'geometry': Point(116.36855, 39.904926),
't': datetime(2009, 3, 10, 11, 3, 35)
}, {
'geometry': Point(116.368612, 39.904877),
't': datetime(2009, 3, 10, 11, 3, 37)
}, {
'geometry': Point(116.368644, 39.90484),
't': datetime(2009, 3, 10, 11, 3, 39)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
intersection = traj.clip(polygon)[0]
result = intersection.to_linestring().wkt
expected_result = "LINESTRING (116.36855 39.904926, 116.368612 39.904877, 116.368644 39.90484)"
self.assertEqual(expected_result, result)
def test_split_by_daybreak(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(-6, 10),
't': datetime(2018, 1, 1, 12, 1, 0)
}, {
'geometry': Point(6, 6),
't': datetime(2018, 1, 3, 12, 0, 1)
}, {
'geometry': Point(6, 16),
't': datetime(2018, 1, 3, 12, 5, 1)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
split = traj.split('daybreak')
result = len(split)
expected_result = 2
self.assertEqual(result, expected_result)
def test_split_by_observation_gap_skip_single_points(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(-6, 10),
't': datetime(2018, 1, 1, 12, 1, 0)
}, {
'geometry': Point(6, 6),
't': datetime(2018, 1, 1, 12, 5, 0)
}, {
'geometry': Point(6, 16),
't': datetime(2018, 1, 1, 12, 6, 30)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
split = traj.split_by_observation_gap(timedelta(seconds=61))
result = len(split)
expected_result = 1
self.assertEqual(expected_result, result)
def test_dist_error_latlon(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(0, 10),
't': datetime(2018, 1, 1, 12, 0, 1)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': 'epsg:4326'})
true_traj = Trajectory(1, geo_df)
true_pos = Point(0, 10)
predicted_pos = Point(0, 9)
dummy_td = timedelta(seconds=1)
sample = TrajectorySample(0, dummy_td, dummy_td, dummy_td, None,
true_pos, true_traj)
evaluator = TrajectoryPredictionEvaluator(sample, predicted_pos,
'epsg:25832', 'epsg:4326')
result = evaluator.get_distance_error()
expected_result = measure_distance_spherical(true_pos, predicted_pos)
self.assertAlmostEqual(result, expected_result, 3)
def test_add_heading(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(6, -6),
't': datetime(2018, 1, 1, 12, 20, 0)
}, {
'geometry': Point(-6, -6),
't': datetime(2018, 1, 1, 12, 30, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
traj.add_heading()
result = traj.df['heading'].tolist()
expected_result = [90.0, 90.0, 180.0, 270]
self.assertEqual(result, expected_result)
def test_sample_after_movement_start(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 11, 0, 57)
}, {
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 11, 0, 58)
}, {
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 11, 0, 59)
}, {
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 1, 0)
}, {
'geometry': Point(0, 1),
't': datetime(2018, 1, 1, 12, 1, 1)
}, {
'geometry': Point(0, 2),
't': datetime(2018, 1, 1, 12, 1, 2)
}, {
'geometry': Point(0, 3),
't': datetime(2018, 1, 1, 12, 1, 3)
}, {
'geometry': Point(0, 4),
't': datetime(2018, 1, 1, 12, 1, 4)
}, {
'geometry': Point(0, 4),
't': datetime(2018, 1, 1, 12, 1, 5)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
sampler = TrajectorySampler(traj)
past_timedelta = timedelta(seconds=2)
future_timedelta = timedelta(seconds=2)
sample = sampler.get_sample(past_timedelta, future_timedelta)
result = sample.future_pos.wkt
expected_result = "POINT (0 4)"
self.assertEqual(result, expected_result)
result = sample.past_traj.to_linestring().wkt
expected_result = "LINESTRING (0 0, 0 1, 0 2)"
self.assertEqual(result, expected_result)
def __init__(self, env, K, T):
self.env = env
self.T = T # time steps per sequence
self.predictor = Predictor(1, 2, 1, self.T)
# self.predictor = Predictor(1, 1, 2, self.T)
self.trajectory = Trajectory(self.env)
self.trajectory.reset()
self.K = K # K sample action sequences
# self.T = T # time steps per sequence
self.lambd = 1
# self.dim_u = self.env.action_space.sample().shape[0]
self.dim_u = 2
self.U = np.zeros([self.T, self.dim_u])
self.time_limit = self.env._max_episode_steps
self.u_init = np.zeros([self.dim_u])
self.cost = np.zeros([self.K])
self.noise = np.random.normal(loc=0,
scale=1,
size=(self.K, self.T, self.dim_u))
def test_get_linestring_between(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(20, 0),
't': datetime(2018, 1, 1, 12, 20, 0)
}, {
'geometry': Point(30, 0),
't': datetime(2018, 1, 1, 12, 30, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_linestring_between(
datetime(2018, 1, 1, 12, 5, 0), datetime(2018, 1, 1, 12, 25, 0,
50)).wkt
expected_result = "LINESTRING (10 0, 20 0)"
self.assertEqual(result, expected_result)
def test_get_position_interpolated_at_timestamp(self):
df = pd.DataFrame([{
'geometry': Point(0, 0),
't': datetime(2018, 1, 1, 12, 0, 0)
}, {
'geometry': Point(6, 0),
't': datetime(2018, 1, 1, 12, 10, 0)
}, {
'geometry': Point(10, 0),
't': datetime(2018, 1, 1, 12, 20, 0)
}]).set_index('t')
geo_df = GeoDataFrame(df, crs={'init': '31256'})
traj = Trajectory(1, geo_df)
result = traj.get_position_at(datetime(2018, 1, 1, 12, 14, 0),
method="interpolated")
expected_result = Point(6 + 4 / 10 * 4, 0)
self.assertEqual(expected_result, result)
result = traj.get_position_at(datetime(2018, 1, 1, 12, 15, 0),
method="interpolated")
expected_result = Point(6 + 4 / 10 * 5, 0)
self.assertEqual(expected_result, result)
