def test_bounds(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() segment_1 = mod_gpx.GPXTrackSegment() segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=-12, longitude=13)) segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=-100, longitude=-5)) segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=100, longitude=-13)) track.segments.append(segment_1) segment_2 = mod_gpx.GPXTrackSegment() segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=-12, longitude=100)) segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=-10, longitude=-5)) segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=10, longitude=-100)) track.segments.append(segment_2) gpx.tracks.append(track) bounds = gpx.get_bounds() self.assertEquals(bounds.min_latitude, -100) self.assertEquals(bounds.max_latitude, 100) self.assertEquals(bounds.min_longitude, -100) self.assertEquals(bounds.max_longitude, 100) # Test refresh bounds: gpx.refresh_bounds() self.assertEquals(gpx.min_latitude, -100) self.assertEquals(gpx.max_latitude, 100) self.assertEquals(gpx.min_longitude, -100) self.assertEquals(gpx.max_longitude, 100)
def test_positions_on_track_2(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() gpx.tracks.append(track) location_to_find_on_track = None # first segment: segment = mod_gpx.GPXTrackSegment() track.segments.append(segment) for i in range(1000): latitude = 45 + i * 0.001 longitude = 45 + i * 0.001 elevation = 100 + i * 2 point = mod_gpx.GPXTrackPoint(latitude=latitude, longitude=longitude, elevation=elevation) segment.points.append(point) if i == 500: location_to_find_on_track = mod_gpx.GPXWaypoint(latitude=latitude, longitude=longitude) # second segment segment = mod_gpx.GPXTrackSegment() track.segments.append(segment) for i in range(1000): latitude = 45.0000001 + i * 0.001 longitude = 45.0000001 + i * 0.001 elevation = 100 + i * 2 point = mod_gpx.GPXTrackPoint(latitude=latitude, longitude=longitude, elevation=elevation) segment.points.append(point) result = gpx.get_nearest_locations(location_to_find_on_track) print 'Found', result self.assertTrue(len(result) == 2)
def process(self): """Processes the action based on selected mode. Prepares the output file and does the XML postprocessing and write. """ # prepare the output out_gpx = gpx.GPX() out_track = gpx.GPXTrack() out_gpx.tracks.append(out_track) self._out_segment = gpx.GPXTrackSegment() out_track.segments.append(self._out_segment) if self._opts['mode'] == 'fill': self.fill() elif self._opts['mode'] == 'merge': self.merge() else: raise StravaGpxException("Invalid processing mode") # postprocessing - namespace out_gpx.nsmap['gpxtpx'] = GARMIN_NS try: with open(self._opts['output'], 'w') as stream: stream.write(out_gpx.to_xml()) except IOError as e: raise StravaGpxException( "Error while wtiting the output XML to file: {}".format( self._opts['output'])) log.info("Output GPX file written to \"{}\"".format( self._opts['output']))
def test_track_with_some_points_are_without_elevations(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() gpx.tracks.append(track) tmp_latlong = 0 segment_1 = mod_gpx.GPXTrackSegment() for i in range(4): point = mod_gpx.GPXTrackPoint(latitude=tmp_latlong, longitude=tmp_latlong) segment_1.points.append(point) if i % 3 == 0: point.elevation = None else: point.elevation = 100 / (i + 1) track.segments.append(segment_1) minimum, maximum = gpx.get_elevation_extremes() self.assertTrue(minimum is not None) self.assertTrue(maximum is not None) uphill, downhill = gpx.get_uphill_downhill() self.assertTrue(uphill is not None) self.assertTrue(downhill is not None)
def main(argv): f = csv.DictReader(sys.stdin) headers = {'Content-Type': 'application/gpx+xml'} good = 0 lowcon = 0 fail = 0 features = [] for row in f: if row["MISSING_DATA"] != "False": fail += 1 continue line = json.loads(row["POLYLINE"]) hitler = gpx.GPX() gpx_track = gpx.GPXTrack() hitler.tracks.append(gpx_track) gpx_segment = gpx.GPXTrackSegment() gpx_track.segments.append(gpx_segment) for point in line: gpx_segment.points.append(gpx.GPXTrackPoint(point[1], point[0])) res = json.loads(requests.post("http://localhost:8989/match", data=hitler.to_xml(), \ params={"vehicle":"car","type":"json","points_encoded":False,"instructions":False, \ "traversal_keys":True,"locale":"pt","gps_accuracy":25}, headers=headers).text) #print res if "paths" not in res: fail += 1 continue good += 1 #print len(res["paths"][0]["points"]["coordinates"]) #print len(line) #print len(res["paths"][0]["instructions"]) #print len(res["traversal_keys"]) if good % 10000 == 0: sys.stderr.write(str(good) + " trips read!\n") #break print_trip(res["traversal_keys"], [t * 15 + int(row["TIMESTAMP"]) for t in res["times"]]) ''' for path in res["paths"]: good += 1 features.append(g.Feature(geometry=path["points"], \ properties={"name": good+fail})) ''' sys.stderr.write(json.dumps({ "good": good, "lowcon": lowcon, "fail": fail })) print ""
def writetogpx(f1, file, conn): try: content = [str(x.strip()) for x in f1] content = [ i for i in content if i.count("[") == 1 and i.count("]") == 1 ] content2 = [] for x in content: try: try: c2 = eval(x).decode('ascii') content2.append(eval(c2)) except AttributeError: content2.append(eval(x)) except ValueError: continue gps_acc = [] for x in content2: if x[5] < 2.0: gps_acc.append(x) c = conn.cursor() try: c.execute("INSERT INTO file (file_name) VALUES('" + file + "')") except: pass if len(gps_acc) == 0: print("No accurate GPS points available!") return gps = [x[2:4] for x in gps_acc] gps_acc = np.array(gps_acc) gps_simple_mask = rdp(gps, epsilon=5e-6, return_mask=True) gps_acc = gps_acc[gps_simple_mask] c.execute("SELECT id from file WHERE file_name='" + file + "'") file_id = c.fetchall()[0][0] for x in gps_acc: if len(x) == 8: osm = int(x[7]) else: osm = 0 writedatabase(conn, x[6], x[2], x[3], x[4], x[1], x[0], x[5], osm, file_id) gpx2 = gpx.GPX() gpx_track2 = gpx.GPXTrack() gpx2.tracks.append(gpx_track2) gpx_segment2 = gpx.GPXTrackSegment() gpx_track2.segments.append(gpx_segment2) for x in gps_acc: gpx_segment2.points.append( gpx.GPXTrackPoint(x[2], x[3], elevation=x[4], time=datetime.datetime.utcfromtimestamp( x[6]))) with open(file + 'reduced.gpx', "w") as f: f.write(gpx2.to_xml()) except: pass
def as_gpx(self): segment = gpx.GPXTrackSegment() for pos in self.trackedposition_set.all(): track_point = gpx.GPXTrackPoint(pos.latitude, pos.longitude, elevation=pos.altitude, time=pos.time) segment.points.append(track_point) track = gpx.GPXTrack() track.segments.append(segment) gpx_obj = gpx.GPX() gpx_obj.tracks.append(track) return gpx_obj.to_xml()
def test_time_bounds(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() segment_1 = mod_gpx.GPXTrackSegment() segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=-12, longitude=13)) segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=-100, longitude=-5, time=mod_datetime.datetime(2001, 1, 12) )) segment_1.points.append(mod_gpx.GPXTrackPoint(latitude=100, longitude=-13 , time=mod_datetime.datetime(2003, 1, 12))) track.segments.append(segment_1) segment_2 = mod_gpx.GPXTrackSegment() segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=-12, longitude=100, time=mod_datetime.datetime(2010, 1, 12))) segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=-10, longitude=-5, time=mod_datetime.datetime(2011, 1, 12))) segment_2.points.append(mod_gpx.GPXTrackPoint(latitude=10, longitude=-100)) track.segments.append(segment_2) gpx.tracks.append(track) bounds = gpx.get_time_bounds() self.assertEquals(bounds.start_time, mod_datetime.datetime(2001, 1, 12)) self.assertEquals(bounds.end_time, mod_datetime.datetime(2011, 1, 12))
def activity_to_gpx(activity: Activity) -> gpx.GPX: points = activity.points g = gpx.GPX() g.creator = f'{APP_NAME} {VERSION}' g.name = activity.metadata.name g.description = activity.metadata.description g.time = activity.metadata.date_time g.nsmap |= NAMESPACES track = gpx.GPXTrack() track.type = activity.metadata.activity_type seg = gpx.GPXTrackSegment() track.segments.append(seg) points.apply(lambda row: _add_point_to_seg(row, seg), axis=1) g.tracks.append(track) return g
def render_route(self, graph, route): gpx = gpxpy.GPX() gpx.name = self._walk_name nodes = graph.nodes() track = gpxpy.GPXTrack() track.name = self._walk_name segment = gpxpy.GPXTrackSegment() track.segments.append(segment) for node_id in route: node = nodes[node_id] segment_point = gpxpy.GPXTrackPoint(latitude=node['y'], longitude=node['x']) segment.points.append(segment_point) gpx.tracks.append(track) with open(self._render_dir.joinpath(f'{self._walk_slug}.gpx'), 'w') as fp: fp.write(gpx.to_xml())
def test_hash_track(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() gpx.tracks.append(track) segment = mod_gpx.GPXTrackSegment() track.segments.append(segment) for i in range(1000): latitude = 45 + i * 0.001 longitude = 45 + i * 0.001 elevation = 100 + i * 2. point = mod_gpx.GPXTrackPoint(latitude=latitude, longitude=longitude, elevation=elevation) segment.points.append(point) self.assertTrue(hash(gpx)) self.assertTrue(len(gpx.tracks) == 1) self.assertTrue(len(gpx.tracks[0].segments) == 1) self.assertTrue(len(gpx.tracks[0].segments[0].points) == 1000) cloned_gpx = mod_copy.deepcopy(gpx) self.assertTrue(hash(gpx) == hash(cloned_gpx)) gpx.tracks[0].segments[0].points[17].elevation *= 2. self.assertTrue(hash(gpx) != hash(cloned_gpx)) gpx.tracks[0].segments[0].points[17].elevation /= 2. self.assertTrue(hash(gpx) == hash(cloned_gpx)) gpx.tracks[0].segments[0].points[17].latitude /= 2. self.assertTrue(hash(gpx) != hash(cloned_gpx)) gpx.tracks[0].segments[0].points[17].latitude *= 2. self.assertTrue(hash(gpx) == hash(cloned_gpx)) del gpx.tracks[0].segments[0].points[17] self.assertTrue(hash(gpx) != hash(cloned_gpx))
def test_get_bounds_and_refresh_bounds(self): gpx = mod_gpx.GPX() latitudes = [] longitudes = [] for i in range(2): track = mod_gpx.GPXTrack() for i in range(2): segment = mod_gpx.GPXTrackSegment() for i in range(10): latitude = 50. * (mod_random.random() - 0.5) longitude = 50. * (mod_random.random() - 0.5) point = mod_gpx.GPXTrackPoint(latitude=latitude, longitude=longitude) segment.points.append(point) latitudes.append(latitude) longitudes.append(longitude) track.segments.append(segment) gpx.tracks.append(track) bounds = gpx.get_bounds() print(latitudes) print(longitudes) self.assertEqual(bounds.min_latitude, min(latitudes)) self.assertEqual(bounds.max_latitude, max(latitudes)) self.assertEqual(bounds.min_longitude, min(longitudes)) self.assertEqual(bounds.max_longitude, max(longitudes)) gpx.refresh_bounds() self.assertEqual(gpx.min_latitude, min(latitudes)) self.assertEqual(gpx.max_latitude, max(latitudes)) self.assertEqual(gpx.min_longitude, min(longitudes)) self.assertEqual(gpx.max_longitude, max(longitudes))
def create_segment(self): self.current_segment = gpx.GPXTrackSegment() self.current_track.segments.append(self.current_segment)
def save_to_gpx(nav_df: pd.DataFrame, fileOutPN, gpx_obj_namef=None, waypoint_symbf=None, cfg_proc=None, gpx=None): # """ Save navigation from dataframe to *.gpx file. track or waypoints. Generate waypoints names and selects symbols from cfg['out']['gpx_symbols'] based on current row in nav_df :param nav_df: DataFrame with fields: if waypoint_symbf: itbl, ... :param fileOutPN: *.gpx file full name without extension. Set None to not write (useful if need only gpx) :param gpx_obj_namef: str or fun(waypoint number). If None then we set it to fileOutPN.stem :param waypoint_symbf: str or fun(nav_df record = row). If None saves track :param cfg_proc: 'simplify_tracks_error_m' 'dt_per_file' 'b_missed_coord_to_zeros' period_segments or period_tracks: to split track by this in one file :param gpx: gpx object to update. If None (default) then will be created here, updated and saved :return: None """ if nav_df.empty: l.warning('no data') return if gpx_obj_namef is None: gpx_obj_namef = Path(fileOutPN).stem if cfg_proc is None: cfg_proc = {'dt_per_file': None} elif not 'dt_per_file' in cfg_proc: cfg_proc['dt_per_file'] = None if gpx is None: gpx = GPX.GPX() if waypoint_symbf: # , fun_symbol= 'Waypoint', fun_name= str if isinstance(waypoint_symbf, str): s = waypoint_symbf waypoint_symbf = lambda x: s b_useDepEcho = 'DepEcho' in nav_df.columns and any(nav_df['DepEcho']) w_names = set() # w_name = None # same perpose for not all conditions but faster # nav_dft= nav_df.reset_index().set_index('itbl', drop=False, append=True) #, inplace=True # for t in range(nav_dft.itbl.min(), nav_dft.itbl.max()+1): #.ptp() = - for t, nav_dft in nav_df.groupby(['itbl']): # .reset_index() for i, r in enumerate(nav_dft.itertuples()): # .loc[t] name=None str_time_short = '{:%d %H:%M}'.format(r.Index.to_pydatetime()) timeUTC = r.Index.tz_convert(None).to_pydatetime() str_time_long = '{:%d.%m.%y %H:%M:%S}'.format(timeUTC) name = gpx_obj_namef if isinstance( gpx_obj_namef, str) else gpx_obj_namef(i, r, t) # remove duplicates by add letter name_test_dup = name i_dup = 0 while name_test_dup in w_names: # name== w_name or : name_test_dup = name + chr(97 + i_dup) # chr(97) = 'a' i_dup += 1 else: name = name_test_dup w_names.add(name) gpx_waypoint = GPX.GPXWaypoint( latitude=r.Lat, longitude=r.Lon, time=timeUTC, description=str_time_long, comment=str_time_short, name=name, symbol=waypoint_symbf(r), elevation=-r.DepEcho if b_useDepEcho and np.isfinite(r.DepEcho) else None) # , description=, type=, comment= # if not i_dup: # w_name = name # to check duplicates on next cycle gpx.waypoints.append(gpx_waypoint) if isinstance(gpx_obj_namef, str): gpx.description = gpx_obj_namef if fileOutPN: gpx.author_email = '*****@*****.**' write_file(fileOutPN, gpx.to_xml()) else: # tracks # loc= np.zeros_like(nav_df.index, dtype= int) # Lat= np.zeros_like(nav_df.index, dtype= np.float64) # Lon= np.zeros_like(nav_df.index, dtype= np.float64) # T= np.zeros_like(nav_df.index, dtype= pd.Timedelta) b_have_depth = ('DepEcho' in nav_df.columns) #b_have_speed = ('Speed' in nav_df.columns) period_split = cfg_proc.get('period_segments') or cfg_proc.get( 'period_tracks') if period_split: period_split = pd_period_to_timedelta(period_split) t_intervals_start = pd.date_range( start=nav_df.index[0].normalize(), end=max(nav_df.index[-1], nav_df.index[-1].normalize() + period_split), freq=period_split)[ 1:] # make last t_interval_start >= all_data[-1] #format_time = else: t_intervals_start = nav_df.index[-1:] # series with 1 last value t_interval_end = nav_df.index[0] n_intervals_without_data = 0 part = 0 nav_df = nav_df.tz_convert('utc', copy=False) Tprev = nav_df.index[0].to_pydatetime() Tcur = Tprev if not cfg_proc.get('period_tracks'): gpx_track = gpx_track_create(gpx, gpx_obj_namef) for t_interval_start in t_intervals_start: t_interval = slice(t_interval_end, t_interval_start) # from previous last # USEtime = [[t_interval_end.isoformat(), t_interval_start.isoformat()]] nav_df_cur = nav_df.truncate(t_interval_end, t_interval_start, copy=True) t_interval_end = t_interval_start # load_interval if not len(nav_df_cur): print('empty interval') n_intervals_without_data += 1 if n_intervals_without_data > 30: print('30 intervals without data => think it is the end') break continue gpx_segment = GPX.GPXTrackSegment() if cfg_proc.get('period_tracks'): track_name = f'{gpx_obj_namef}{t_interval_start:%y-%m-%d %H:%M}' gpx_track = gpx_track_create(gpx, track_name) gpx_track[track_name].segments.append(gpx_segment) else: gpx_track[gpx_obj_namef].segments.append(gpx_segment) for i, r in enumerate(nav_df_cur.itertuples()): Tcur = r.Index.to_pydatetime() gpx_point = GPX.GPXTrackPoint( latitude=r.Lat, longitude=r.Lon, elevation=r.DepEcho if b_have_depth and not np.isnan(r.DepEcho) else None, time=Tcur) # , speed= speed_b, comment= Comment gpx_segment.points.append(gpx_point) # if i==1: # gpx.description= gpx_obj_namef # gpx.author_email= '*****@*****.**' # gpxxml= gpx.to_xml() # tree = ET.parse(gpxxml) # root = tree.getroot() if cfg_proc.get('simplify_tracks_error_m'): try: gpx_segment.points = gpxpy_simplify_polyline( gpx_segment.points, cfg_proc['simplify_tracks_error_m']) except RecursionError as e: recursion_limit = sys.getrecursionlimit() l.error( 'Check time in data! Why increasing old recursion limit (%s) is needed? Trying: x10...', recursion_limit) try: sys.setrecursionlimit(recursion_limit * 10) gpx_segment.points = gpxpy_simplify_polyline( gpx_segment.points, cfg_proc['simplify_tracks_error_m']) l.warning('now track simplified successfuly') except Exception as e: l.exception('not succes. skip simplifying tracks', recursion_limit) if cfg_proc['dt_per_file'] and Tcur - Tprev > cfg_proc[ 'dt_per_file']: # save to next file part += 1 if fileOutPN: gpx_proc_and_save(gpx, gpx_obj_namef, cfg_proc, f'{fileOutPN}part{part}') gpx_track = gpx_track_create(gpx, gpx_obj_namef) Tprev = Tcur if fileOutPN: gpx_proc_and_save(gpx, gpx_obj_namef, cfg_proc, fileOutPN) return gpx
def parse_smses(cfg): """ Parse valid messages: old tracker: lat:54.719937 long:20.525533 speed:0.00 dir:0.0\nT:21/02/16 01:45\nhttp://maps.google.com/maps?f=q&q=54.719937,20.525533&z=16 new tracker: lat:54.735578\nlong:20.544967\nspeed:0.07 \nT:19/10/13 05:03\nbat:100%\nhttp://maps.google.com/maps?f=q&q=54.735578,20.544967&z=16 (special_symbol ( |&) parsing not need because replaced by ET.parse) :param cfg: :return: """ r_coord_val = '\d{1,3}\.\d{1,8}' r_lat = f'(?: ?lat:)(?P<Lat>{r_coord_val})' r_lon = f'(?:long:)(?P<Lon>{r_coord_val})' r_speed = '(?:speed:)(?P<Speed>\d{1,3}\.\d{1,3})' r_time = '(?:\nT:)(?P<Time>\d\d/\d\d/\d\d \d\d\:\d\d)' # search time string '24/02/16 20:40' re_msg = [] for b_new in [False, True]: if b_new: r_dir = ' ' r_sep = '\n' r_power = '(?:\nbat:)(?P<Power>\d{1,3})(?:%)' r_z = '((?:&z=)(?P<Z>\d{1,3})|)' else: r_dir = '(?: dir:)(?P<Dir>\d{1,3})' r_sep = ' ' r_power = '((?:&z=)(?P<Z>\d{1,3})|)' r_z = '' re_msg.append( re.compile( f'{r_lat}{r_sep}{r_lon}{r_sep}{r_speed}{r_dir}{r_time}{r_power}.*{r_z}' )) bWriteComments = 'b_write_comments' in cfg['process'] and cfg['process'][ 'b_write_comments'] bWriteWithoutCoord = 'b_write_without_coord' in cfg['process'] and cfg[ 'process']['b_write_without_coord'] bAllTimeFromStamp = 'b_all_time_from_stamp' in cfg['process'] and cfg[ 'process']['b_all_time_from_stamp'] # min_str_date= cfg['process']['min_str_date'] if 'min_str_date' in cfg['process'] else datetime.strptime('01.01.2010', '%d.%m.%Y') min_date = cfg['process']['min_date'] if 'min_date' in cfg[ 'process'] else datetime.strptime('01.01.2010', '%d.%m.%Y') re_msgBad = re.compile(f'^(?P<Comment>[^T]*){r_time}.*') # re_msg= re.compile('^(?P<Comment>[^\:]*?)(?: ?lat[:])(?P<Lat>\d{1,3}\.\d{1,8}) (?:long[:])(?P<Lon>\d{1,3}\.\d{1,8}) \ # (?:speed[:])(?P<Speed>\d{1,3}\.\d{1,3}) (?:dir[:])(?P<Dir>\d{1,3}).*' + r_time) kmh2ms = 1000.0 / 3600.0 getFromStamp = lambda n: datetime.utcfromtimestamp(int(n.attrib['date'] if \ len(n.attrib['date_sent']) <= 1 else n.attrib[ 'date_sent']) / 1000.0) # 'date2' def gettime(node=None, m_groupTime=None, b_year_first=None): """ :param node: :param m_groupTime: :param b_year_first: if None act like bAllTimeFromStamp == True :return: """ if bAllTimeFromStamp or (b_year_first is None): time_b = getFromStamp(node) if time_b < min_date: return None else: try: time_b = datetime.strptime( m_groupTime, r'%y/%m/%d %H:%M' if b_year_first else r'%d/%m/%y %H:%M') - cfg['in']['dt_from_utc'] if time_b < min_date: raise ValueError except ValueError: time_b = getFromStamp(node) if time_b > min_date: print('bad time: "' + m_groupTime + '" replaced by stamp') else: return None return time_b tree = ET.parse(cfg['in']['path']) root = tree.getroot() # Create tracks in our GPX gpx = GPX.GPX() gpx_track = {} # gpx.tracks= [GPX.GPXTrack(name = c) for c in contacts] # gpx_track= dict(zip(contacts, gpx.tracks)) for contact_name in cfg['in']['contacts']: contact_name_d = contact_name # .decode('cp1251') #allow Russian letters in contact names # try: # print('contact name: ', contact_name_d) # except UnicodeEncodeError: # contact_name_d= contact_name.decode('utf-8') #.encode('cp1251') time_b_prev = datetime.now() # or any big value gpx_track[contact_name] = GPX.GPXTrack(name=contact_name_d) # if gpx_track[contact_name].number: #.get_points_no(): print('contact name: ', contact_name_d) # else: # continue gpx.tracks.append(gpx_track[contact_name]) # Create segment in this GPX track: gpx_segment = GPX.GPXTrackSegment() gpx_track[contact_name].segments.append(gpx_segment) old_or_new = [False, True] b_year_first = None for neighbor in root.findall("./sms/[@contact_name='" + contact_name_d + "'][@type='1']"): # received SMS # Parse messages: body = neighbor.attrib['body'] for b_new in old_or_new: m = re_msg[b_new].search(body) if not m is None: old_or_new = [b_new ] # fix neweness for contact for speedup b_year_first = b_new break if (not m is None) and ( not m.group(1) is None): # valid => create points: Comment = m.group('Comment') if bWriteComments else None time_b = gettime(neighbor, m.group('Time'), b_year_first=b_year_first) if not time_b: continue # Add segment for big time intervals: if time_b - time_b_prev > cfg['out'][ 'dt_between_track_segments']: gpx_segment = GPX.GPXTrackSegment() gpx_track[contact_name].segments.append(gpx_segment) time_b_prev = time_b if m.group('Speed') != '0.00': speed_b = round(float(m.group('Speed')) * kmh2ms, 5) else: speed_b = '0' # work around: gpxpy not writes 0 if float gpx_point = GPX.GPXTrackPoint( latitude=m.group('Lat'), longitude=m.group('Lon'), elevation=m.group('Z') if 'Z' in m.re.groupindex.keys() else None, time=time_b, speed=speed_b, comment=Comment) if 'Dir' in m.re.groupindex.keys(): gpx_point.course = m.group('Dir') # where to write dir? elif bWriteWithoutCoord: # invalid => messages m = re_msgBad.match(body) if (not m is None) and ( not m.group(1) is None): # valid time=> create comment Comment = m.group('Comment') if bWriteComments else None time_b = gettime(neighbor, m.group('Time'), b_year_first=b_year_first) if not time_b: continue gpx_point = GPX.GPXTrackPoint(time=time_b, comment=Comment) else: # get Time from message receive time stamp Comment = body if bWriteComments else None # Consider full message as comment try: time_b = getFromStamp(neighbor) if time_b < min_date: continue # raise ValueError except: time_b = None print('can not find time in message and time stamp') continue gpx_point = GPX.GPXTrackPoint(time=time_b) else: continue gpx_segment.points.append(gpx_point) gpx.description = contact_name_d gpx.author_email = '*****@*****.**' return gpx
def test_ignore_maximums_for_max_speed(self): gpx = mod_gpx.GPX() track = mod_gpx.GPXTrack() gpx.tracks.append(track) tmp_time = mod_datetime.datetime.now() tmp_longitude = 0 segment_1 = mod_gpx.GPXTrackSegment() for i in range(4): segment_1.points.append( mod_gpx.GPXTrackPoint(latitude=0, longitude=tmp_longitude, time=tmp_time)) tmp_longitude += 0.01 tmp_time += mod_datetime.timedelta(hours=1) track.segments.append(segment_1) moving_time, stopped_time, moving_distance, stopped_distance, max_speed_with_too_small_segment = gpx.get_moving_data( ) # Too few points: mod_logging.debug('max_speed = %s', max_speed_with_too_small_segment) self.assertFalse(max_speed_with_too_small_segment) tmp_longitude = 0. segment_2 = mod_gpx.GPXTrackSegment() for i in range(55): segment_2.points.append( mod_gpx.GPXTrackPoint(latitude=0, longitude=tmp_longitude, time=tmp_time)) tmp_longitude += 0.01 tmp_time += mod_datetime.timedelta(hours=1) track.segments.append(segment_2) moving_time, stopped_time, moving_distance, stopped_distance, max_speed_with_equal_speeds = gpx.get_moving_data( ) mod_logging.debug('max_speed = %s', max_speed_with_equal_speeds) self.assertTrue(max_speed_with_equal_speeds > 0) # When we add to few extreemes, they should be ignored: for i in range(10): segment_2.points.append( mod_gpx.GPXTrackPoint(latitude=0, longitude=tmp_longitude, time=tmp_time)) tmp_longitude += 0.7 tmp_time += mod_datetime.timedelta(hours=1) moving_time, stopped_time, moving_distance, stopped_distance, max_speed_with_extreemes = gpx.get_moving_data( ) self.assertTrue( abs(max_speed_with_extreemes - max_speed_with_equal_speeds) < 0.001) # But if there are many extreemes (they are no more extreemes): for i in range(100): # Sometimes add on start, sometimes on end: if i % 2 == 0: segment_2.points.append( mod_gpx.GPXTrackPoint(latitude=0, longitude=tmp_longitude, time=tmp_time)) else: segment_2.points.insert( 0, mod_gpx.GPXTrackPoint(latitude=0, longitude=tmp_longitude, time=tmp_time)) tmp_longitude += 0.5 tmp_time += mod_datetime.timedelta(hours=1) moving_time, stopped_time, moving_distance, stopped_distance, max_speed_with_more_extreemes = gpx.get_moving_data( ) mod_logging.debug('max_speed_with_more_extreemes = %s', max_speed_with_more_extreemes) mod_logging.debug('max_speed_with_extreemes = %s', max_speed_with_extreemes) self.assertTrue( max_speed_with_more_extreemes - max_speed_with_extreemes > 10)