def random_walk2(octal_window, verbose=False):
# print("running random walk 2")
d = get_distance(octal_window)[0][:-1]
l = d.mean()
ls = d.std()
b = get_bearing(octal_window)[0][:-1]
t = b.mean()
ts = b.std()
l = np.random.normal(l, ls, 1)
t = np.radians(np.random.normal(t, ts, 1))
pl = octal_window.iloc[3, :]
p1 = octal_window.iloc[2, :]
p2 = octal_window.iloc[4, :]
dy = l * np.cos(t)
dx = l * np.sin(t)
r_earth = 6378000
pi = np.pi
new_latitude = p1.lat + (dy / r_earth) * (180 / pi)
new_longitude = p1.lon + (dx / r_earth) * (180 / pi) / np.cos(
p1.lat * pi / 180)
pc = (new_latitude, new_longitude)
d = float(haversine(pc, (pl.lat, pl.lon)))
return p1, p2, pc, d
def random_walk(octal_window):
if len(octal_window) < 3:
raise Exception("window size should be more than 3")
mid = int(len(octal_window) / 2)
pl = octal_window.iloc[mid, :]
reverse_octal_windows = octal_window[::-1]
d = get_distance(octal_window)[0][:mid + 1]
l = d.mean()
ls = d.std()
b = get_bearing(octal_window)[0][:mid + 1]
t = b.mean()
ts = b.std()
l = np.random.normal(l, ls, 1)
t = np.radians(np.random.normal(t, ts, 1))
p1 = octal_window.iloc[mid - 1, :]
dy = l * np.cos(t)
dx = l * np.sin(t)
r_earth = 6378000
pi = np.pi
new_latitude = p1.lat + (dy / r_earth) * (180 / pi)
new_longitude = p1.lon + (dx / r_earth) * (180 / pi) / np.cos(
p1.lat * pi / 180)
pf = (new_latitude, new_longitude)
d = get_distance(reverse_octal_windows)[0][:mid + 1]
l = d.mean()
ls = d.std()
b = get_bearing(reverse_octal_windows)[0][:mid + 1]
t = b.mean()
ts = b.std()
l = np.random.normal(l, ls, 1)
t = np.radians(np.random.normal(t, ts, 1))
p2 = reverse_octal_windows.iloc[mid - 1, :]
dy = l * np.cos(t)
dx = l * np.sin(t)
r_earth = 6378000
pi = np.pi
new_latitude = p2.lat + (dy / r_earth) * (180 / pi)
new_longitude = p2.lon + (dx / r_earth) * (180 / pi) / np.cos(
p2.lat * pi / 180)
pb = (new_latitude, new_longitude)
pc = ((pf[0] + pb[0]) / 2, (pf[1] + pb[1]) / 2)
d = float(haversine(pc, (pl.lat, pl.lon)))
return p1, p2, pc, d
def linear(octal_window,verbose=False):
#if len(octal_window)!=5:
# raise Exception("Linear only get window size 3")
mid = int(len(octal_window) / 2)
lat = octal_window.lat.values
lon = octal_window.lon.values
pc = ((lat[mid-1] + lat[mid+1]) / 2, (lon[mid-1] + lon[mid+1]) / 2)
d = haversine(pc, (lat[mid], lon[mid]))
return (lat[mid-1], lon[mid-1]), (lat[mid+1], lon[mid+1]), pc, d
def core(trajectory, theta_distance, theta_time, verbose=False):
i = 0
point_num = trajectory.shape[0] # the number of GPS points in traj
S = [] # set of stay points
segments = [-1] * point_num
stay_point_id = 0
while i < point_num:
j = i + 1
while j < point_num:
p_i = trajectory.iloc[i, :]
p_j = trajectory.iloc[j, :]
distance = haversine((p_i.lat, p_i.lon),
(p_j.lat, p_j.lon)) # calculate haversine distance between two points
if distance > theta_distance:
p_i_T = p_i.name
p_j_T = p_j.name
delta_t = (p_j_T - p_i_T).total_seconds()
if delta_t > theta_time:
s = StayPoint()
stay_point_id = stay_point_id + 1
s.lat = np.mean(trajectory.iloc[i:j, :].lat)
s.lon = np.mean(trajectory.iloc[i:j, :].lon)
s.arrive_time = p_i_T
s.leave_time = p_j_T
s.i = i
s.j = j
S.append(s)
for _ in range(i, j):
segments[_] = stay_point_id
break
j = j + 1
i = j
segments2 = segments
ss = np.max(segments) + 1
i = 0
while i < point_num:
j = i + 1
while (j < point_num) and (segments[j] == -1) and (segments[j] < segments[i]):
segments2[j] = ss
j = j + 1
ss = np.max(segments2) + 1
i = i + 1
segment_id = np.add(segments2, [2] * len(segments2))
return segment_id
def kinematic(octal_window, verbose=False):
#print("kin")
if len(octal_window) != 7:
raise Exception("kin only gets window size 7")
lat = octal_window.lat.values
lon = octal_window.lon.values
#print(list(zip(lat,lon)))
#start = octal_window.index.values.min()
#td = (octal_window.index.values - start) # / np.timedelta64(1, 's')
#td=td.seconds
td = ((octal_window.index.values - octal_window.index.values.min()) /
1000000000).astype(float)
#print(td)
lat2 = np.append(lat[1:], lat[-1:])
lon2 = np.append(lon[1:], lon[-1:])
# R = 3959.87433 # this is in miles. For Earth radius in kilometers use 6372.8 km
# r = 6372.8
d_lat, d_lon, lat1, lat2 = map(np.radians,
(lat2 - lat, lon2 - lon, lat, lat2))
#print(d_lat, d_lon, lat1, lat2)
a = np.sin(
d_lat / 2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(d_lon / 2)**2
# distance_val = 2 * np.arcsin(np.sqrt(a)) * r * 1000 # convert to meter
# distance_val = distance_val[:-1]
S_lat = np.diff(lat) / td[1:]
S_lon = np.diff(lon) / td[1:]
a_lat = np.diff(S_lat) / td[2:]
a_lon = np.diff(S_lon) / td[2:]
t3 = (td[2] + td[4]) / 2
# (t3, td[3])
lat3 = a_lat[0] * (t3 * t3) + S_lat[1] * t3
lon3 = a_lon[0] * (t3 * t3) + S_lon[1] * t3
p1 = (lat[2] + lat3, lon[2] + lon3)
lat = lat[::-1]
lon = lon[::-1]
td = td[::-1]
lat2 = np.append(lat[1:], lat[-1:])
lon2 = np.append(lon[1:], lon[-1:])
# r = 6372.8
d_lat, d_lon, lat1, lat2 = map(np.radians,
(lat2 - lat, lon2 - lon, lat, lat2))
a = np.sin(
d_lat / 2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(d_lon / 2)**2
# distance_val = 2 * np.arcsin(np.sqrt(a)) * r * 1000 # convert to meter
# distance_val = distance_val[:-1]
S_lat = np.diff(lat) / td[1:]
S_lon = np.diff(lon) / td[1:]
a_lat = np.diff(S_lat) / td[2:]
a_lon = np.diff(S_lon) / td[2:]
# print(td)
t3 = (td[2] + td[4]) / 2
# (t3, td[3])
lat3 = a_lat[0] * (t3 * t3) + S_lat[1] * t3
lon3 = a_lon[0] * (t3 * t3) + S_lon[1] * t3
p2 = (lat[2] + lat3, lon[2] + lon3)
pc = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
l = (lat[3], lon[3])
d = haversine(pc, l)
#if np.isnan(d):
#print(d, p1, p2, pc, l)
return p1, p2, pc, d
def cubic(octal_window, verbose=False):
if len(octal_window) < 3:
raise Exception("window size should be more than 3")
try:
lat = octal_window.lat.values
lon = octal_window.lon.values
mid = int(len(lon) / 2)
x3 = lat[mid]
y3 = lon[mid]
lat = np.delete(lat, mid)
lon = np.delete(lon, mid)
t = np.diff(octal_window.index) / 1000000000
t3 = t[mid]
t = np.delete(t, mid)
t = np.cumsum(t)
t = np.insert(t, 0, 0).astype(float)
from scipy.interpolate import CubicSpline
latcs = CubicSpline(np.abs(t), lat)
new_x = latcs(t3)
loncs = CubicSpline(np.abs(t), lon)
new_y = loncs(t3)
#fx = interp1d(t, lat, kind='cubic')
#fy = interp1d(t, lon, kind='cubic')
#new_x = fx(t3)
#new_y = fy(t3)
pf = (new_x, new_y)
#reverse
lat = octal_window.lat.values[::-1]
lon = octal_window.lon.values[::-1]
tidx = octal_window.index[::-1]
x3 = lat[mid]
y3 = lon[mid]
lat = np.delete(lat, mid)
lon = np.delete(lon, mid)
t = np.diff(tidx) / 1000000000
t3 = t[mid]
t = np.delete(t, mid)
t = np.cumsum(t)
t = np.insert(t, 0, 0).astype(float)
from scipy.interpolate import CubicSpline
latcs = CubicSpline(np.abs(t), lat)
new_x = latcs(t3)
loncs = CubicSpline(np.abs(t), lon)
new_y = loncs(t3)
#fx = interp1d(t, lat, kind='cubic',fill_value="extrapolate")
#fy = interp1d(t, lon, kind='cubic',fill_value="extrapolate")
#new_x = fx(t3)
#new_y = fy(t3)
pb = (new_x, new_y)
pc = ((pf[0] + pb[0]) / 2, (pf[1] + pb[1]) / 2)
d = haversine(pc, (x3, y3))
except Exception as e:
if verbose:
print(t, e)
print(octal_window)
d = 0
return pf, pb, pc, d
def linear_regression(octal_window, verbose=False):
lat = np.array(octal_window.lat.values)
lon = np.array(octal_window.lon.values)
td = ((octal_window.index.values - octal_window.index.values.min()) /
1000000000).astype(float)
mid = int(len(lon) / 2)
lat_f = lat[:mid]
td_f = td[:mid]
# print(lat_f, td[mid])
LR_lat = LinearRegression()
LR_lat.fit(td_f.reshape(-1, 1), lat_f.reshape(-1, 1))
y_pred_lat = LR_lat.predict(np.array(td[mid]).reshape(-1, 1))
# print(y_pred_lat[0][0])
lat_f = y_pred_lat[0][0]
# print(LR_lat.intercept_, LR_lat.coef_)
# abline(LR_lat.coef_[0], LR_lat.intercept_[0])
# plt.scatter(td[mid], y_pred_lat[0][0], c='r')
lat_b = lat[mid:][::-1]
td_b = td[mid:][::-1]
# print(lat_b, td[mid])
LR_lat = LinearRegression()
LR_lat.fit(td_b.reshape(-1, 1), lat_b.reshape(-1, 1))
y_pred_lat = LR_lat.predict(np.array(td[mid]).reshape(-1, 1))
# print(y_pred_lat[0][0])
# print(LR_lat.intercept_, LR_lat.coef_)
# abline(LR_lat.coef_[0], LR_lat.intercept_[0])
# plt.scatter(td[mid], y_pred_lat[0][0], c='r')
lat_b = y_pred_lat[0][0]
lat_pred = (lat_f + lat_b) / 2
# plt.scatter(td[mid], lat_pred, c='g')
# plt.show()
# print("lon")
# plt.scatter(td, lon)
mid = int(len(lon) / 2)
# td =np.array(((octal_window.index.values - octal_window.index.values.min()) / 1000000000).astype(float))
lon_f = lon[:mid]
td_f = td[:mid]
# print(lon_f, td[mid])
LR_lon = LinearRegression()
LR_lon.fit(td_f.reshape(-1, 1), lon_f.reshape(-1, 1))
y_pred_lon = LR_lon.predict(np.array(td[mid]).reshape(-1, 1))
# print(y_pred_lon[0][0])
lon_f = y_pred_lon[0][0]
# print(LR_lon.intercept_, LR_lon.coef_)
# abline(LR_lon.coef_[0], LR_lon.intercept_[0])
# plt.scatter(td[mid], y_pred_lon[0][0], c='y')
lon_b = lon[mid:][::-1]
td_b = td[mid:][::-1]
# print(lon_b, td[mid])
LR_lon = LinearRegression()
LR_lon.fit(td_b.reshape(-1, 1), lon_b.reshape(-1, 1))
y_pred_lon = LR_lon.predict(np.array(td[mid]).reshape(-1, 1))
# print(y_pred_lon[0][0])
# print(LR_lon.intercept_, LR_lon.coef_)
# abline(LR_lon.coef_[0], LR_lon.intercept_[0])
# plt.scatter(td[mid], y_pred_lon[0][0], c='r')
lon_b = y_pred_lon[0][0]
lon_pred = (lon_f + lon_b) / 2
# plt.scatter(td[mid], lon_pred, c='g')
# plt.show()
# print(lat[mid], lon[mid])
# print(lat_pred, lon_pred)
pc = (lat[mid], lon[mid])
p1 = p2 = (lat_pred, lon_pred)
d = haversine((lat[mid], lon[mid]), (lat_pred, lon_pred))
return p1, p2, pc, d