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