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