def gpx_export(move):
gpx = gpxpy.gpx.GPX()
gpx.creator = "OpenMoves - http://www.openmoves.net/"
# Create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
# Create first segment in our GPX track:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
# Create points:
gps_samples = move.samples.filter(
Sample.sample_type.like('gps-%')).order_by(Sample.time.asc())
if gps_samples.count() == 0:
flash("No GPS samples found for GPX export", 'error')
return None
for gps_sample in gps_samples:
gpx_segment.points.append(
gpxpy.gpx.GPXTrackPoint(
latitude=radian_to_degree(gps_sample.latitude),
longitude=radian_to_degree(gps_sample.longitude),
elevation=gps_sample.gps_altitude,
time=move.date_time + gps_sample.time,
position_dilution=gps_sample.gps_hdop))
# You can add routes and waypoints, too...
return gpx.to_xml()
def postprocess_move(move):
gps_samples = [sample for sample in move.samples if sample.sample_type and sample.sample_type.startswith('gps-')]
if gps_samples:
gps_center = calculate_gps_center(gps_samples)
move.gps_center_latitude = gps_center[0]
move.gps_center_longitude = gps_center[1]
gps_center_degrees = [radian_to_degree(x) for x in gps_center]
gps_center_max_distance = 0
for sample in gps_samples:
point = (sample.latitude, sample.longitude)
point_degrees = [radian_to_degree(x) for x in point]
distance = vincenty(gps_center_degrees, point_degrees).meters
gps_center_max_distance = max(gps_center_max_distance, distance)
move.gps_center_max_distance = gps_center_max_distance
first_sample = gps_samples[0]
latitude = first_sample.latitude
longitude = first_sample.longitude
geolocator = Nominatim()
location = geolocator.reverse("%f, %f" % (radian_to_degree(latitude), radian_to_degree(longitude)), timeout=60)
move.location_address = location.address
move.location_raw = location.raw
def insert_pause(samples, insert_pause_idx, move, pause_type):
if (insert_pause_idx <= 0):
return
stop_sample = samples[insert_pause_idx - 1]
start_sample = samples[insert_pause_idx]
pause_duration = start_sample.time - stop_sample.time
pause_distance = distance(
(radian_to_degree(
stop_sample.latitude), radian_to_degree(stop_sample.longitude)),
(radian_to_degree(start_sample.latitude),
radian_to_degree(start_sample.longitude))).meters
# Introduce start of pause sample
pause_sample = Sample()
pause_sample.move = move
pause_sample.utc = stop_sample.utc
pause_sample.time = stop_sample.time
stop_sample.utc -= timedelta(
microseconds=1
) # Cut off 1ms from last recorded sample in order to introduce the new pause sample and keep time order
stop_sample.time -= timedelta(microseconds=1)
pause_sample.events = {
"pause": {
"state": "True",
"type": str(pause_type),
"duration": str(pause_duration),
"distance": str(pause_distance),
}
}
samples.insert(insert_pause_idx, pause_sample) # Duplicate last element
# Introduce end of pause sample
pause_sample = Sample()
pause_sample.move = move
pause_sample.utc = start_sample.utc
pause_sample.time = start_sample.time
start_sample.utc += timedelta(
microseconds=1
) # Add 1ms to the first recorded sample in order to introduce the new pause sample and keep time order
start_sample.time += timedelta(microseconds=1)
pause_sample.events = {
"pause": {
"state": "False",
"duration": "0",
"distance": "0",
"type": str(pause_type)
}
}
samples.insert(insert_pause_idx + 1, pause_sample)
def postprocess_move(move):
if move.public is None:
move.public = False
gps_samples = [sample for sample in move.samples if sample.sample_type and sample.sample_type.startswith('gps-')]
if gps_samples:
first_sample = gps_samples[0]
latitude = first_sample.latitude
longitude = first_sample.longitude
if latitude and longitude:
geo_locator = Nominatim(user_agent='openmoves.net')
location = geo_locator.reverse("%f, %f" % (radian_to_degree(latitude), radian_to_degree(longitude)), timeout=60)
move.location_address = location.address
move.location_raw = location.raw
def insert_pause(samples, insert_pause_idx, move, pause_type):
if (insert_pause_idx <= 0):
return
stop_sample = samples[insert_pause_idx - 1]
start_sample = samples[insert_pause_idx]
pause_duration = start_sample.time - stop_sample.time
pause_distance = distance((radian_to_degree(stop_sample.latitude), radian_to_degree(stop_sample.longitude)),
(radian_to_degree(start_sample.latitude), radian_to_degree(start_sample.longitude))).meters
# Introduce start of pause sample
pause_sample = Sample()
pause_sample.move = move
pause_sample.utc = stop_sample.utc
pause_sample.time = stop_sample.time
stop_sample.utc -= timedelta(microseconds=1) # Cut off 1ms from last recorded sample in order to introduce the new pause sample and keep time order
stop_sample.time -= timedelta(microseconds=1)
pause_sample.events = {"pause": {"state": "True",
"type": str(pause_type),
"duration": str(pause_duration),
"distance": str(pause_distance),
}}
samples.insert(insert_pause_idx, pause_sample) # Duplicate last element
# Introduce end of pause sample
pause_sample = Sample()
pause_sample.move = move
pause_sample.utc = start_sample.utc
pause_sample.time = start_sample.time
start_sample.utc += timedelta(microseconds=1) # Add 1ms to the first recorded sample in order to introduce the new pause sample and keep time order
start_sample.time += timedelta(microseconds=1)
pause_sample.events = {"pause": {"state": "False",
"duration": "0",
"distance": "0",
"type": str(pause_type)
}}
samples.insert(insert_pause_idx + 1, pause_sample)
def postprocess_move(move):
if move.public is None:
move.public = False
gps_samples = [
sample for sample in move.samples
if sample.sample_type and sample.sample_type.startswith('gps-')
]
if gps_samples:
first_sample = gps_samples[0]
latitude = first_sample.latitude
longitude = first_sample.longitude
if latitude and longitude:
geo_locator = Nominatim(user_agent='openmoves.net')
location = geo_locator.reverse(
"%f, %f" %
(radian_to_degree(latitude), radian_to_degree(longitude)),
timeout=60)
move.location_address = location.address
move.location_raw = location.raw
def parse_samples(tree, move, gpx_namespace):
all_samples = []
tracks = tree.iterchildren(tag=gpx_namespace + GPX_TRK)
for track in tracks:
track_samples = []
track_segments = track.iterchildren(tag=gpx_namespace + GPX_TRKSEG)
for track_segment in track_segments:
segment_samples = []
track_points = track_segment.iterchildren(tag=gpx_namespace + GPX_TRKPT)
for track_point in track_points:
sample = Sample()
sample.move = move
# GPS position / altitude
sample.latitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LATITUDE]))
sample.longitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LONGITUDE]))
sample.sample_type = "gps-base"
if hasattr(track_point, GPX_TRKPT_ATTRIB_ELEVATION):
sample.gps_altitude = float(track_point.ele)
sample.altitude = int(round(sample.gps_altitude))
# Time / UTC
sample.utc = dateutil.parser.parse(str(track_point.time))
if len(segment_samples) > 0:
# Accumulate time delta to previous sample to get the total duration
time_delta = sample.utc - segment_samples[-1].utc
sample.time = segment_samples[-1].time + time_delta
# Accumulate distance to previous sample
distance_delta = vincenty(
(radian_to_degree(sample.latitude), radian_to_degree(sample.longitude)),
(
radian_to_degree(segment_samples[-1].latitude),
radian_to_degree(segment_samples[-1].longitude),
),
).meters
sample.distance = segment_samples[-1].distance + distance_delta
if time_delta > timedelta(0):
sample.speed = distance_delta / time_delta.total_seconds()
else:
sample.speed = 0
elif len(track_samples) > 0:
sample.time = track_samples[-1].time
sample.distance = track_samples[-1].distance
sample.speed = track_samples[-1].speed
elif len(all_samples) > 0:
sample.time = all_samples[-1].time
sample.distance = all_samples[-1].distance
sample.speed = all_samples[-1].speed
else:
sample.time = timedelta(0)
sample.distance = 0
sample.speed = 0
parse_sample_extensions(sample, track_point)
segment_samples.append(sample)
# Insert an pause event between every tracksegment
insert_pause(track_samples, segment_samples)
track_samples.extend(segment_samples)
# Insert an pause event between every track
insert_pause(all_samples, track_samples)
all_samples.extend(track_samples)
return all_samples
def parse_samples(tree, move, gpx_namespace, import_options):
all_samples = []
tracks = tree.iterchildren(tag=gpx_namespace + GPX_TRK)
for track in tracks:
track_samples = []
track_segments = track.iterchildren(tag=gpx_namespace + GPX_TRKSEG)
for track_segment in track_segments:
segment_samples = []
track_points = track_segment.iterchildren(tag=gpx_namespace + GPX_TRKPT)
for track_point in track_points:
sample = Sample()
sample.move = move
# GPS position / altitude
sample.latitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LATITUDE]))
sample.longitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LONGITUDE]))
sample.sample_type = GPX_SAMPLE_TYPE
if hasattr(track_point, GPX_TRKPT_ATTRIB_ELEVATION):
sample.gps_altitude = float(track_point.ele)
sample.altitude = int(round(sample.gps_altitude))
# Time / UTC
sample.utc = dateutil.parser.parse(str(track_point.time))
# Option flags
pause_detected = False
# Track segment samples
if len(segment_samples) > 0:
# Accumulate time delta to previous sample to get the total duration
time_delta = sample.utc - segment_samples[-1].utc
sample.time = segment_samples[-1].time + time_delta
# Accumulate distance to previous sample
distance_delta = distance((radian_to_degree(sample.latitude), radian_to_degree(sample.longitude)),
(radian_to_degree(segment_samples[-1].latitude), radian_to_degree(segment_samples[-1].longitude))).meters
sample.distance = segment_samples[-1].distance + distance_delta
if time_delta > timedelta(0):
sample.speed = distance_delta / time_delta.total_seconds()
else:
sample.speed = 0
# Option: Pause detection based on time delta threshold
if GPX_IMPORT_OPTION_PAUSE_DETECTION in import_options and time_delta > import_options[GPX_IMPORT_OPTION_PAUSE_DETECTION]:
pause_detected = True
sample.distance = segment_samples[-1].distance
sample.speed = 0
# Track segment -> Track (multiple track segments contained)
elif len(track_samples) > 0:
sample.time = track_samples[-1].time + (sample.utc - track_samples[-1].utc) # Time diff to last sample of the previous track segment
sample.distance = track_samples[-1].distance
sample.speed = 0
# Track -> Full GPX (multiple tracks contained)
elif len(all_samples) > 0:
sample.time = all_samples[-1].time + (sample.utc - all_samples[-1].utc) # Time diff to last sample of the previous track
sample.distance = all_samples[-1].distance
sample.speed = 0
# First sample
else:
sample.time = timedelta(0)
sample.distance = 0
sample.speed = 0
parse_sample_extensions(sample, track_point)
segment_samples.append(sample)
# Finally insert a found pause based on time delta threshold
if pause_detected:
insert_pause(segment_samples, len(segment_samples) - 1, move, pause_type=GPX_IMPORT_PAUSE_TYPE_PAUSE_DETECTION)
# end for track_points
# Insert an pause event between every track segment
insert_pause_idx = len(track_samples)
track_samples.extend(segment_samples)
insert_pause(track_samples, insert_pause_idx, move, pause_type=GPX_TRKSEG)
# end for track_segments
# Insert an pause event between every track
insert_pause_idx = len(all_samples)
all_samples.extend(track_samples)
insert_pause(all_samples, insert_pause_idx, move, pause_type=GPX_TRK)
# end for tracks
return all_samples
def _sample_to_point(sample):
return (radian_to_degree(sample.latitude),
radian_to_degree(sample.longitude))
def parse_samples(tree, move, gpx_namespace, import_options):
all_samples = []
tracks = tree.iterchildren(tag=gpx_namespace + GPX_TRK)
for track in tracks:
track_samples = []
track_segments = track.iterchildren(tag=gpx_namespace + GPX_TRKSEG)
for track_segment in track_segments:
segment_samples = []
track_points = track_segment.iterchildren(tag=gpx_namespace + GPX_TRKPT)
for track_point in track_points:
sample = Sample()
sample.move = move
# GPS position / altitude
sample.latitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LATITUDE]))
sample.longitude = degree_to_radian(float(track_point.attrib[GPX_TRKPT_ATTRIB_LONGITUDE]))
sample.sample_type = GPX_SAMPLE_TYPE
if hasattr(track_point, GPX_TRKPT_ATTRIB_ELEVATION):
sample.gps_altitude = float(track_point.ele)
sample.altitude = int(round(sample.gps_altitude))
# Time / UTC
sample.utc = dateutil.parser.parse(str(track_point.time))
# Option flags
pause_detected = False
# Track segment samples
if len(segment_samples) > 0:
# Accumulate time delta to previous sample to get the total duration
time_delta = sample.utc - segment_samples[-1].utc
sample.time = segment_samples[-1].time + time_delta
# Accumulate distance to previous sample
distance_delta = vincenty((radian_to_degree(sample.latitude), radian_to_degree(sample.longitude)),
(radian_to_degree(segment_samples[-1].latitude), radian_to_degree(segment_samples[-1].longitude))).meters
sample.distance = segment_samples[-1].distance + distance_delta
if time_delta > timedelta(0):
sample.speed = distance_delta / time_delta.total_seconds()
else:
sample.speed = 0
# Option: Pause detection based on time delta threshold
if GPX_IMPORT_OPTION_PAUSE_DETECTION in import_options and time_delta > import_options[GPX_IMPORT_OPTION_PAUSE_DETECTION]:
pause_detected = True
sample.distance = segment_samples[-1].distance
sample.speed = 0
# Track segment -> Track (multiple track segments contained)
elif len(track_samples) > 0:
sample.time = track_samples[-1].time + (sample.utc - track_samples[-1].utc) # Time diff to last sample of the previous track segment
sample.distance = track_samples[-1].distance
sample.speed = 0
# Track -> Full GPX (multiple tracks contained)
elif len(all_samples) > 0:
sample.time = all_samples[-1].time + (sample.utc - all_samples[-1].utc) # Time diff to last sample of the previous track
sample.distance = all_samples[-1].distance
sample.speed = 0
# First sample
else:
sample.time = timedelta(0)
sample.distance = 0
sample.speed = 0
parse_sample_extensions(sample, track_point)
segment_samples.append(sample)
# Finally insert a found pause based on time delta threshold
if pause_detected:
insert_pause(segment_samples, len(segment_samples) - 1, move, pause_type=GPX_IMPORT_PAUSE_TYPE_PAUSE_DETECTION)
# end for track_points
# Insert an pause event between every track segment
insert_pause_idx = len(track_samples)
track_samples.extend(segment_samples)
insert_pause(track_samples, insert_pause_idx, move, pause_type=GPX_TRKSEG)
# end for track_segments
# Insert an pause event between every track
insert_pause_idx = len(all_samples)
all_samples.extend(track_samples)
insert_pause(all_samples, insert_pause_idx, move, pause_type=GPX_TRK)
# end for tracks
return all_samples
def _sample_to_point(sample):
return (radian_to_degree(sample.latitude), radian_to_degree(sample.longitude))
