def test_reduce_gpx_file(self):
f = open('test_files/Mojstrovka.gpx')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
max_reduced_points_no = 200
started = mod_time.time()
gpx = parser.parse()
points_original = gpx.get_track_points_no()
time_original = mod_time.time() - started
gpx.reduce_points(max_reduced_points_no)
points_reduced = gpx.get_track_points_no()
result = gpx.to_xml()
result = result.encode('utf-8')
started = mod_time.time()
parser = mod_parser.GPXParser(result, parser=self.get_parser_type())
parser.parse()
time_reduced = mod_time.time() - started
print(time_original)
print(points_original)
print(time_reduced)
print(points_reduced)
self.assertTrue(time_reduced < time_original)
self.assertTrue(points_reduced < points_original)
self.assertTrue(points_reduced < max_reduced_points_no)
def __init__(self, gpx_file):
with open(gpx_file, 'r') as f:
try:
p = parser.GPXParser(f)
self.gpx = p.parse(f)
except gpx.GPXException as e:
raise InvalidGPXFile(_("Invalid GPX file: %s" % str(e)))
def test_clone_and_smooth(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
original_2d = gpx.length_2d()
original_3d = gpx.length_3d()
cloned_gpx = gpx.clone()
self.assertTrue(hash(gpx) == hash(cloned_gpx))
cloned_gpx.reduce_points(2000, min_distance=10)
cloned_gpx.smooth(vertical=True, horizontal=True)
cloned_gpx.smooth(vertical=True, horizontal=False)
print('2d:', gpx.length_2d())
print('2d cloned and smoothed:', cloned_gpx.length_2d())
print('3d:', gpx.length_3d())
print('3d cloned and smoothed:', cloned_gpx.length_3d())
self.assertTrue(gpx.length_3d() == original_3d)
self.assertTrue(gpx.length_2d() == original_2d)
self.assertTrue(gpx.length_3d() > cloned_gpx.length_3d())
self.assertTrue(gpx.length_2d() > cloned_gpx.length_2d())
def test_moving_stopped_times(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f)
gpx = parser.parse()
f.close()
print gpx.get_track_points_no()
#gpx.reduce_points(1000, min_distance=5)
print gpx.get_track_points_no()
length = gpx.length_3d()
print 'Distance: %s' % length
gpx.reduce_points(2000, min_distance=10)
gpx.smooth(vertical=True, horizontal=True)
gpx.smooth(vertical=True, horizontal=False)
moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data(stopped_speed_treshold=0.1)
print '-----'
print 'Length: %s' % length
print 'Moving time: %s (%smin)' % (moving_time, moving_time / 60.)
print 'Stopped time: %s (%smin)' % (stopped_time, stopped_time / 60.)
print 'Moving distance: %s' % moving_distance
print 'Stopped distance: %s' % stopped_distance
print 'Max speed: %sm/s' % max_speed
print '-----'
# TODO: More tests and checks
self.assertTrue(moving_distance < length)
print 'Dakle:', moving_distance, length
self.assertTrue(moving_distance > 0.75 * length)
self.assertTrue(stopped_distance < 0.1 * length)
def test_split(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
track = gpx.tracks[1]
track_points_no = track.get_points_no()
before = len(track.segments)
track.split(0, 10)
after = len(track.segments)
self.assertTrue(before + 1 == after)
print('Points in first (splitted) part:',
len(track.segments[0].points))
# From 0 to 10th point == 11 points:
self.assertTrue(len(track.segments[0].points) == 11)
self.assertTrue(
len(track.segments[0].points) +
len(track.segments[1].points) == track_points_no)
# Now split the second track
track.split(1, 20)
self.assertTrue(len(track.segments[1].points) == 21)
self.assertTrue(
len(track.segments[0].points) + len(track.segments[1].points) +
len(track.segments[2].points) == track_points_no)
def applyPrivacyZone(inFileName, coordsAddresses, radii, outFileName=None):
"""
Copy GPX track from inFileName into outFileName, rejecting all waypoints
within a "privacy zone" defined in arrays (of equal length!)
"coordsAddresses" (GPS coordinates or uniquely resolvable addresses)
and "radii" (as units.quantity Quantities).
outFileName defaults to inFile_pz.gpx
"""
if outFileName is None:
outFileName=inFileName[:inFileName.index('.gpx')]+'_pz.gpx'
pz = privacyZone(coordsAddresses, radii)
with open(inFileName, 'r') as f:
parser=gpxParser.GPXParser(f)
parser.parse()
gpx=parser.gpx
# Delete points within privacyZone
for track in gpx.tracks:
for seg in track.segments:
### Watch out: can't pop from a list while iterating (forward!) over it
### (it's not syntactically forbidden, but it messes with indexing)
### So, iterating backward.
for i in range(len(seg.points)-1, -1, -1):
if pz.isPointTooClose(seg.points[i]):
seg.points.pop(i)
with open(outFileName, 'w') as out:
out.write(gpx.to_xml())
return
def build_location_history(inpath, target_tz=None):
from_zone = tz.tzutc()
to_zone = tz.tzlocal() if target_tz is None else tz.gettz(target_tz)
gpx_parser = None
with open(inpath, 'r') as gpx_file:
gpx_parser = parser.GPXParser(gpx_file)
gpx_parser.parse()
gpx = gpx_parser.gpx
all_points = []
for track in gpx.tracks:
for segment in track.segments:
print 'Adding points from a segment'
all_points += segment.points
# for point in segment.points:
# print 'Point at ({0},{1}) -> {2}, at {3}'.format( point.latitude, point.longitude, point.elevation, point.time )
for point in all_points:
utc_time = point.time.replace(tzinfo=from_zone)
point.time = utc_time.astimezone(to_zone)
# for waypoint in gpx.waypoints:
# print 'waypoint {0} -> ({1},{2})'.format( waypoint.name, waypoint.latitude, waypoint.longitude )
#
# for route in gpx.routes:
# print 'Route:'
# for point in route:
# print 'Point at ({0},{1}) -> {2}'.format( point.latitude, point.longitude, point.elevation )
return LocationHistory(all_points)
def __reparse(self, gpx):
xml = gpx.to_xml()
parser = mod_parser.GPXParser(xml, parser=self.get_parser_type())
gpx = parser.parse()
if not gpx:
print('Parser error while reparsing: %s' % parser.get_error())
return gpx
def __parse(self, file):
f = open('test_files/%s' % file)
parser = mod_parser.GPXParser(f)
gpx = parser.parse()
f.close()
if not gpx:
print 'Parser error: %s' % parser.get_error()
return gpx
def load_tracks(ship):
filepath = ship[0]
print('Parsing file ' + filepath)
gpx_file = open(filepath, 'r')
gpx_parser = parser.GPXParser(gpx_file)
gpx = gpx_parser.parse()
gpx_file.close()
# load tracks
tracks = []
for vertices in gpx.tracks:
tracks.append(ShipTrack(vertices, {"name": ship[1], "color": ship[2]}))
return tracks
def test_split_on_impossible_index(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
track = gpx.tracks[0]
before = len(track.segments)
track.split(1000, 10)
after = len(track.segments)
self.assertTrue(before == after)
def parse_gpx(gpx_file):
gpx_file = open('Laffing_i_ghettoen.gpx', 'r')
gpx_parser = parser.GPXParser(gpx_file)
gpx_parser.parse()
gpx_file.close()
gpx = gpx_parser.parse()
x = []
for track in gpx.tracks:
for segment in track.segments:
for point in segment.points:
x.append(point.time)
return x
def load_points(filename):
logger = logging.getLogger(__name__)
points = []
with open(filename, 'r') as gpx_file:
gpx_parser = parser.GPXParser(gpx_file)
gpx_parser.parse()
gpx = gpx_parser.gpx
for track in gpx.tracks:
for segment in track.segments:
points.extend(segment.points)
logger.debug('loaded {s} points from {f}'.format(s=len(points),
f=filename))
return points
def __parse(self, file, encoding=None):
if PYTHON_VERSION[0] == '3':
f = open('test_files/%s' % file, encoding=encoding)
else:
f = open('test_files/%s' % file)
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
if not gpx:
print('Parser error: %s' % parser.get_error())
return gpx
def test_horizontal_and_vertical_smooth_remove_extremes(self):
f = open('test_files/track-with-extremes.gpx', 'r')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
points_before = gpx.get_track_points_no()
gpx.smooth(vertical=True, horizontal=True, remove_extremes=True)
points_after = gpx.get_track_points_no()
print(points_before)
print(points_after)
self.assertTrue(points_before - 3 == points_after)
def test_vertical_smooth_remove_extreemes(self):
f = open('test_files/track-with-extreemes.gpx', 'r')
parser = mod_parser.GPXParser(f)
gpx = parser.parse()
points_before = gpx.get_track_points_no()
gpx.smooth(vertical=True, horizontal=False, remove_extreemes=True)
points_after = gpx.get_track_points_no()
print points_before
print points_after
self.assertTrue(points_before - 1 == points_after)
def test_remove_point_from_segment(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f)
gpx = parser.parse()
f.close()
track = gpx.tracks[1]
segment = track.segments[0]
original_segment = segment.clone()
segment.remove_point(3)
print segment.points[0]
print original_segment.points[0]
self.assertTrue(equals(segment.points[0], original_segment.points[0]))
self.assertTrue(equals(segment.points[1], original_segment.points[1]))
self.assertTrue(equals(segment.points[2], original_segment.points[2]))
# ...but:
self.assertTrue(equals(segment.points[3], original_segment.points[4]))
self.assertTrue(len(segment.points) + 1 == len(original_segment.points))
def shiftTimes(inFileName, nHours, outFileName=None):
"""
add nHours hours to all times given in inFileName (waypoints)
outFileName defaults to inFile_timewarp.gpx
"""
from datetime import timedelta
if outFileName is None:
outFileName=inFileName[:inFileName.index('.gpx')]+'_timewarp.gpx'
timeShift=timedelta(hours=nHours)
with open(inFileName, 'r') as f:
parser=gpxParser.GPXParser(f)
parser.parse()
gpx=parser.gpx
for track in gpx.tracks:
for seg in track.segments:
for point in seg.points:
point.time = point.time+timeShift
with open(outFileName, 'w') as out:
out.write(gpx.to_xml())
return
def test_split_and_join(self):
f = open('test_files/cerknicko-jezero.gpx')
parser = mod_parser.GPXParser(f, parser=self.get_parser_type())
gpx = parser.parse()
f.close()
track = gpx.tracks[1]
original_track = track.clone()
track.split(0, 10)
track.split(1, 20)
self.assertTrue(len(track.segments) == 3)
track.join(1)
self.assertTrue(len(track.segments) == 2)
track.join(0)
self.assertTrue(len(track.segments) == 1)
# Check that this splitted and joined track is the same as the original one:
self.assertTrue(equals(track, original_track))
def mergeTracks(self, fileNames, outFileName, fillers=[]):
# Read in files
gpxes=[]
for fn in fileNames:
with open(fn, 'r') as f:
parser=gpxParser.GPXParser(f)
parser.parse()
gpx=parser.gpx
gpxes.append(gpx)
print ("Done reading in ", fn)
# Sort by time
startTimes=[]
endTimes=[]
for gpx in gpxes:
startTimes.append(gpx.tracks[0].segments[0].points[0].time)
endTimes.append(gpx.tracks[-1].segments[-1].points[-1].time)
idx=np.argsort(startTimes)
gpxesSorted=np.array(gpxes)[idx]
fnSorted=np.array(fileNames)[idx]
startTimesSorted=np.array(startTimes)[idx]
endTimesSorted=np.array(endTimes)[idx]
# Make sure there's no time overlap between files
for i in range(len(startTimesSorted)-1):
if not startTimesSorted[i+1] > endTimesSorted[i]:
print("Time overlap between files %i and %i"%(i,i+1))
print(fnSorted[i], fnSorted[i+1])
print("Endtime of first: ", endTimesSorted[i])
print("StartTime of second:", startTimesSorted[i+1])
assert False
for fn, start, end in zip(fnSorted, startTimesSorted, endTimesSorted):
print (fn, start, end)
out=gpxesSorted[0]
for gpx in gpxesSorted[1:]:
for track in gpx.tracks:
out.tracks.append(track)
output=out.to_xml()
with open(outFileName, 'w') as out:
out.write(output)
def parse_gpx_data(gpx_file_name):
gpx_file = open(gpx_file_name, 'r')
gpx_parser = parser.GPXParser(gpx_file)
gpx = gpx_parser.parse()
gpx_file.close()
track_list = []
for track in gpx.tracks:
for segment in track.segments:
for point in segment.points:
if point.extensions != {}:
speed = point.extensions['gpxtpx:speed']
else:
speed = 0
track_list.append({
'lat': point.latitude,
'lon': point.longitude,
'ele': point.elevation,
'time': point.time,
'speed': speed
})
return track_list
def __init__(self, gpxstring):
self.gpx = parser.GPXParser(gpxstring).parse()
#!/usr/bin/env python
import gpxpy.parser as parser
import csv
import sys
writer = csv.writer(sys.stdout)
gpx_file = open('activity_1284067099.gpx', 'r')
gpx_parser = parser.GPXParser(gpx_file)
gpx = gpx_parser.parse()
gpx_file.close()
#print gpx.get_points_data()
result = []
#gpx = gpx_parser.get_gpx()
for track in gpx.tracks:
first_ts = track.segments[0].points[0].time
last_ts = first_ts
first_pt = track.segments[0].points[0]
last_pt = first_pt
for segment in track.segments:
for point in segment.points:
diff = point.time - last_ts
diff_start = point.time - first_ts
writer.writerow([
diff.total_seconds() * 10,
import numpy as np
import matplotlib.pyplot as plt
import gpxpy.parser as ps
from mpl_toolkits.mplot3d.art3d import Poly3DCollection as poly
from mpl_toolkits import mplot3d
#parse --> get data
gpx_file = open('track.gpx', 'r')
gpx_parser = ps.GPXParser(gpx_file)
gpx = gpx_parser.parse()
gpx_file.close()
data_list = []
for track in gpx.tracks:
for segment in track.segments:
for point in segment.points:
data_res = []
data_res.append(float(point.latitude))
data_res.append(float(point.longitude))
data_res.append(float(point.elevation))
for extension in point.extensions:
data_res.append(float(extension.text))
if len(data_res) != 4:
continue
data_list.append(data_res)
data = np.array(data_list)
#setting
