def _find_movement_end(self, points): i=len(points)-1 while i > 0: p1 = json.loads(repr(self.tcx_data[i-1])) p2 = json.loads(repr(self.tcx_data[i])) time1 = dt.datetime.strptime(p1["time"], "%Y-%m-%dT%H:%M:%S.%fZ") time2 = dt.datetime.strptime(p2["time"], "%Y-%m-%dT%H:%M:%S.%fZ") time = (time2 - time1).total_seconds() latitude1 = None if "latitudedegrees" not in p1 else float(p1["latitudedegrees"]) longitude1 = None if "longitudedegrees" not in p1 else float(p1["longitudedegrees"]) latitude2 = None if "latitudedegrees" not in p2 else float(p2["latitudedegrees"]) longitude2 = None if "longitudedegrees" not in p2 else float(p2["longitudedegrees"]) if latitude1 is None and longitude1 is None: # invalid point 1 latitude1 = 0.0 if latitude2 is None else latitude2 longitude1 = 0.0 if longitude2 is None else longitude2 if latitude2 is None and longitude2 is None: # invalid point 2 latitude2 = 0.0 if latitude1 is None else latitude1 longitude2 = 0.0 if longitude1 is None else longitude1 dist = geo_distance((latitude1, longitude1),(latitude2, longitude2)).m if time>0: speed = dist/time if speed > SPEED_NO_MOVEMENT_LIMIT_M_PER_S: break i-=1 return i
def compute_distance(self, station_id_1, station_id_2):
lat_1 = self.stops_info[station_id_1]['stop_lat']
lon_1 = self.stops_info[station_id_1]['stop_lon']
lat_2 = self.stops_info[station_id_2]['stop_lat']
lon_2 = self.stops_info[station_id_2]['stop_lon']
distance = geo_distance((lat_1, lon_1), (lat_2, lon_2)).m
return distance
def station_distances(self, lat, lon):
distances = []
index = []
for station in self.station_metadata.itertuples():
index.append(station.Index)
distance = geo_distance([lat,lon], [station.latitude, station.longitude]).km
distances.append(distance)
distances = pd.Series(distances, index=index)
return distances
def update_distance(self):
self.distance = geo_distance(self.coordinate,
self.owner.coordinate).feet
if self.nearby:
if self.distance > self.geo_fence:
self.nearby = False
self.delegate.bag_did_move_away(self)
else:
if self.distance < self.geo_fence:
self.nearby = True
self.delegate.bag_did_come_near(self)
def _compute_matrix(target, vectors):
result = []
for t in target:
res = []
for v in vectors:
d = geo_distance(t, v).kilometers
res.append(d)
result.append(res)
if not result:
return numpy.empty((0, 2), dtype=numpy.float32)
return numpy.array(result, dtype=numpy.float32)
def _find_movement_start(self, points):
i = 1
while i < len(points):
p1 = points[i - 1]
p2 = points[i]
dist = geo_distance((p1.latitude, p1.longitude),
(p2.latitude, p2.longitude)).m
time = (p2.time - p1.time).total_seconds()
if time > 0:
speed = dist / time
if speed > SPEED_NO_MOVEMENT_LIMIT_M_PER_S:
break
i += 1
return i - 1
def _find_movement_end(self, points):
i = len(points) - 1
while i > 0:
p1 = self.fit_data[i - 1]
p2 = self.fit_data[i]
time = (p2["time"] - p1["time"]).total_seconds()
dist = geo_distance((p1["latitude"], p1["longitude"]),
(p2["latitude"], p2["longitude"])).m
if time > 0:
speed = dist / time
if speed > SPEED_NO_MOVEMENT_LIMIT_M_PER_S:
break
i -= 1
return i
def find_closest_city(lat, long, acceptable_distance=15, model_type='current'):
'''
find a the city data for "type" (current or predict) that's
"distance" kilometers away from
existing city in db if it exists
return city id of closest city within acceptable_distance
'''
if model_type == 'current':
queryset = InternationalCurrent.objects.all()
else:
queryset = GlobalPredict.objects.all()
min_distance = acceptable_distance + 1
origin_coordinates = (lat, long)
city_id = None
# find min distance
for city in queryset:
distance = geo_distance(origin_coordinates,
(city.latitude, city.longitude))
if distance < min_distance:
min_distance = distance
city_id = city.city_id
return city_id
def _process_track_points(self, points):
track_data = list()
split_data = list()
summary = None
cumulative_duration = 0.0
cumulative_distance = 0.0
cumulative_elevation_gain = 0.0
start_dist_current_split = 0
start_dur_current_split = 0
start_ele_current_split = 0
for idx in range(len(points)):
if idx == 0:
track_data.append(
WorkoutDataPoint(points[idx].latitude,
points[idx].longitude,
points[idx].elevation, points[idx].time,
0, 0, 0))
start_ele_current_split = track_data[0].elevation
else:
point = points[idx]
previous_point = points[idx - 1]
# duration
time_diff = round(
(point.time - previous_point.time).total_seconds(), 1)
cumulative_duration += time_diff
# distance
elevation_diff = floor(point.elevation -
previous_point.elevation)
distance_diff_2d = geo_distance(
(previous_point.latitude, previous_point.longitude),
(point.latitude, point.longitude)).m
cumulative_distance += sqrt(distance_diff_2d**2 +
(elevation_diff)**2)
# speed & elevation gain, slightly averaged
avg_speed_kmh = 0
if idx > 4:
previous_point5 = points[idx - 5]
speed_elevation_diff = floor(point.elevation -
previous_point5.elevation)
speed_time_diff = round(
(point.time - previous_point5.time).total_seconds(), 1)
speed_dist_diff_2d = geo_distance(
(previous_point5.latitude, previous_point5.longitude),
(point.latitude, point.longitude)).m
speed_dist_diff_3d = sqrt(speed_dist_diff_2d**2 +
(speed_elevation_diff)**2)
if (speed_elevation_diff /
5) > ELEVATION_GAIN_IGNORE_LIMIT_M:
cumulative_elevation_gain += (speed_elevation_diff / 5)
if speed_time_diff > 0:
avg_speed_kmh = 3.6 * speed_dist_diff_3d / speed_time_diff
# add record
track_data.append(
WorkoutDataPoint(point.latitude, point.longitude,
point.elevation, point.time,
cumulative_duration, cumulative_distance,
avg_speed_kmh))
# splits
if cumulative_distance - start_dist_current_split >= SPLIT_DISTANCE_M or idx == (
len(points) - 1):
split_point = objcopy(track_data[-1])
split_point.distance -= start_dist_current_split
split_point.duration -= start_dur_current_split
split_point.elevation -= start_ele_current_split
if split_point.duration > 0:
split_point.average_speed = 3.6 * split_point.distance / split_point.duration
else:
split_point.average_speed = 0.0
split_data.append(split_point)
start_dist_current_split = cumulative_distance
start_dur_current_split = cumulative_duration
start_ele_current_split = track_data[-1].elevation
# hack to set speed for first records
if idx == 5:
track_data[0].average_speed = track_data[5].average_speed
track_data[1].average_speed = track_data[5].average_speed
track_data[2].average_speed = track_data[5].average_speed
track_data[3].average_speed = track_data[5].average_speed
track_data[4].average_speed = track_data[5].average_speed
# summary
if len(track_data) > 0:
# summary contains: start lat./long., total elevation gain, total duration, total distance, avg speed
first_point = points[0]
last_track_data = track_data[-1]
total_avg_speed_kmh = 3.6 * last_track_data.distance / last_track_data.duration
summary = WorkoutDataPoint(
first_point.latitude, first_point.longitude,
cumulative_elevation_gain, first_point.time,
last_track_data.duration, last_track_data.distance,
total_avg_speed_kmh)
return track_data, split_data, summary
def get_track_data(self):
if self.get_num_of_tracks() > 0:
track_data = list()
split_data = list()
summary = None
cumulative_duration = 0.0
cumulative_distance = 0.0
cumulative_elevation_gain = 0.0
cumulative_heart_bpm = 0.0
heart_rate_points = 0
start_dist_current_split = 0
start_dur_current_split = 0
start_ele_current_split = 0
for idx in range(len(self.fit_data)):
if idx == 0:
point = self.fit_data[idx]
if point['heart_rate'] > 0:
cumulative_heart_bpm += point['heart_rate']
heart_rate_points += 1
track_data.append(
WorkoutDataPoint(point["latitude"], point["longitude"],
point["elevation"], point["time"], 0,
0, 0, point['heart_rate']))
start_ele_current_split = point["elevation"]
else:
point = self.fit_data[idx]
previous_point = self.fit_data[idx - 1]
# duration
time_diff = round((point['time'] -
previous_point['time']).total_seconds(),
1)
cumulative_duration += time_diff
# distance
elevation_diff = floor(point['elevation'] -
previous_point['elevation'])
distance_diff_2d = geo_distance(
(previous_point['latitude'],
previous_point['longitude']),
(point['latitude'], point['longitude'])).m
cumulative_distance += sqrt(distance_diff_2d**2 +
(elevation_diff)**2)
# heart rate
if point['heart_rate'] > 0:
cumulative_heart_bpm += point['heart_rate']
heart_rate_points += 1
# speed & elevation gain, slightly averaged
avg_speed_kmh = 0
if idx > 4:
previous_point5 = self.fit_data[idx - 5]
speed_elevation_diff = floor(
point['elevation'] - previous_point5['elevation'])
speed_time_diff = round(
(point['time'] -
previous_point5['time']).total_seconds(), 1)
speed_dist_diff_2d = geo_distance(
(previous_point5['latitude'],
previous_point5['longitude']),
(point['latitude'], point['longitude'])).m
speed_dist_diff_3d = sqrt(speed_dist_diff_2d**2 +
(speed_elevation_diff)**2)
if (speed_elevation_diff /
5) > ELEVATION_GAIN_IGNORE_LIMIT_M:
cumulative_elevation_gain += (
speed_elevation_diff / 5)
if speed_time_diff > 0:
avg_speed_kmh = 3.6 * speed_dist_diff_3d / speed_time_diff
# add record
track_data.append(
WorkoutDataPoint(point["latitude"], point["longitude"],
point["elevation"], point["time"],
cumulative_duration,
cumulative_distance, avg_speed_kmh,
point['heart_rate']))
# splits
if cumulative_distance - start_dist_current_split >= SPLIT_DISTANCE_M or idx == (
len(self.fit_data) - 1):
split_point = objcopy(track_data[-1])
split_point.distance -= start_dist_current_split
split_point.duration -= start_dur_current_split
split_point.elevation -= start_ele_current_split
if split_point.duration > 0:
split_point.average_speed = 3.6 * split_point.distance / split_point.duration
else:
split_point.average_speed = 0.0
split_data.append(split_point)
start_dist_current_split = cumulative_distance
start_dur_current_split = cumulative_duration
start_ele_current_split = track_data[-1].elevation
# hack to set speed for first records
if idx == 5:
track_data[0].average_speed = track_data[
5].average_speed
track_data[1].average_speed = track_data[
5].average_speed
track_data[2].average_speed = track_data[
5].average_speed
track_data[3].average_speed = track_data[
5].average_speed
track_data[4].average_speed = track_data[
5].average_speed
# summary
if len(track_data) > 0:
# summary contains: start lat./long., total elevation gain, total duration, total distance, avg speed
first_point = track_data[0]
last_point = track_data[-1]
total_avg_speed_kmh = 3.6 * last_point.distance / last_point.duration
avg_heart_rate = 0
if heart_rate_points > 0:
avg_heart_rate = cumulative_heart_bpm / heart_rate_points
summary = WorkoutDataPoint(
first_point.latitude, first_point.longitude,
cumulative_elevation_gain, first_point.time,
last_point.duration, last_point.distance,
total_avg_speed_kmh, avg_heart_rate)
return track_data, split_data, summary
else: # no tracks
return None, None, None
def get_track_data(self): if self.get_num_of_tracks() > 0: track_data = list() split_data = list() summary = None cumulative_duration = 0.0 cumulative_distance = 0.0 cumulative_elevation_gain = 0.0 cumulative_heart_bpm = 0.0 heart_rate_points = 0 start_dist_current_split = 0 start_dur_current_split = 0 start_ele_current_split = 0 for idx in range(len(self.tcx_data)): if idx == 0: point = json.loads(repr(self.tcx_data[idx])) elevation = 0.0 if "altitudemeters" not in point else float(point["altitudemeters"]) time = dt.datetime.strptime(point["time"], "%Y-%m-%dT%H:%M:%S.%fZ") heart_bpm = 0 if "heartratebpm" not in point else int(point["heartratebpm"]) if heart_bpm > 0: cumulative_heart_bpm += heart_bpm heart_rate_points += 1 track_data.append(WorkoutDataPoint( float(point["latitudedegrees"]), float(point["longitudedegrees"]), elevation, time, 0, 0, 0, heart_bpm)) start_ele_current_split = round(elevation, None) else: point = json.loads(repr(self.tcx_data[idx])) previous_point = json.loads(repr(self.tcx_data[idx-1])) # duration time = dt.datetime.strptime(point["time"], "%Y-%m-%dT%H:%M:%S.%fZ") time_previous = dt.datetime.strptime(previous_point["time"], "%Y-%m-%dT%H:%M:%S.%fZ") time_diff = round((time - time_previous).total_seconds(), 1) cumulative_duration += time_diff # distance elevation = 0.0 if "altitudemeters" not in point else float(point["altitudemeters"]) elevation_previous = 0.0 if "altitudemeters" not in previous_point else float(previous_point["altitudemeters"]) elevation_diff = floor(elevation - elevation_previous) latitude = float(point["latitudedegrees"]) longitude = float(point["longitudedegrees"]) latitude_previous = float(previous_point["latitudedegrees"]) longitude_previous = float(previous_point["longitudedegrees"]) distance_diff_2d = geo_distance((latitude_previous, longitude_previous), (latitude, longitude)).m cumulative_distance += sqrt(distance_diff_2d**2 + (elevation_diff)**2) #heart rate heart_bpm = 0 if "heartratebpm" not in point else int(point["heartratebpm"]) if heart_bpm > 0: cumulative_heart_bpm += heart_bpm heart_rate_points += 1 # speed & elevation gain, slightly averaged avg_speed_kmh = 0 if idx > 4: previous_point5 = json.loads(repr(self.tcx_data[idx-5])) elevation_previous5 = 0.0 if "altitudemeters" not in previous_point5 else float(previous_point5["altitudemeters"]) latitude_previous5 = float(previous_point5["latitudedegrees"]) longitude_previous5 = float(previous_point5["longitudedegrees"]) speed_elevation_diff = floor(elevation - elevation_previous5) speed_time_diff = round((time - dt.datetime.strptime(previous_point5["time"], "%Y-%m-%dT%H:%M:%S.%fZ")).total_seconds(), 1) speed_dist_diff_2d = geo_distance((latitude_previous5, longitude_previous5), (latitude, longitude)).m speed_dist_diff_3d = sqrt(speed_dist_diff_2d**2 + (speed_elevation_diff)**2) if (speed_elevation_diff / 5) > ELEVATION_GAIN_IGNORE_LIMIT_M: cumulative_elevation_gain += (speed_elevation_diff / 5) if speed_time_diff > 0: avg_speed_kmh = 3.6 * speed_dist_diff_3d / speed_time_diff # add record track_data.append(WorkoutDataPoint( latitude, longitude, elevation, time, cumulative_duration, cumulative_distance, avg_speed_kmh, heart_bpm)) # splits if cumulative_distance-start_dist_current_split >= SPLIT_DISTANCE_M or idx == (len(self.tcx_data)-1): split_point = objcopy(track_data[-1]) split_point.distance -= start_dist_current_split split_point.duration -= start_dur_current_split split_point.elevation -= start_ele_current_split if split_point.duration > 0: split_point.average_speed = 3.6 * split_point.distance / split_point.duration else: split_point.average_speed = 0.0 split_data.append(split_point) start_dist_current_split = cumulative_distance start_dur_current_split = cumulative_duration start_ele_current_split = track_data[-1].elevation # hack to set speed for first records if idx == 5: track_data[0].average_speed = track_data[5].average_speed track_data[1].average_speed = track_data[5].average_speed track_data[2].average_speed = track_data[5].average_speed track_data[3].average_speed = track_data[5].average_speed track_data[4].average_speed = track_data[5].average_speed # summary if len(track_data) > 0: # summary contains: start lat./long., total elevation gain, total duration, total distance, avg speed first_point = track_data[0] last_point = track_data[-1] total_avg_speed_kmh = 3.6 * last_point.distance / last_point.duration avg_heart_rate = 0 if heart_rate_points > 0: avg_heart_rate = cumulative_heart_bpm / heart_rate_points summary = WorkoutDataPoint(first_point.latitude, first_point.longitude, cumulative_elevation_gain, first_point.time, last_point.duration, last_point.distance, total_avg_speed_kmh, avg_heart_rate) return track_data, split_data, summary else: return None, None, None
def earth_coord_2_local_coord(lat, lon):
x = geo_distance((lat, lon), (lat, LOCAL_COORD_ORIGIN_LONGITUD))
y = geo_distance((lat, lon), (LOCAL_COORD_ORIGIN_LATITUD, lon))
return x, y
