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 test_positions_on_track(self):
gpx = mod_gpx.GPX()
track = mod_gpx.GPXTrack()
gpx.tracks.append(track)
segment = mod_gpx.GPXTrackSegment()
track.segments.append(segment)
location_to_find_on_track = None
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)
result = gpx.get_nearest_locations(location_to_find_on_track)
self.assertTrue(len(result) == 1)
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 getMP_GPX(self, mp_URL_email):
pos = 0
gpxinstance = gpx.GPX()
mp_todos = self.getToDos(mp_URL_email, pos)
#requery the API if we've reached 200 and there's still something returned
while (len(mp_todos['toDos']) > 0):
if (pos > 0): #requery the API to get next 200 batch
mp_todos = self.getToDos(mp_URL_email, pos)
#get routes returns an array of integer route ids, make a string to pass to MP
route_ids = ','.join(str(todo) for todo in mp_todos['toDos'])
if len(route_ids) > 0:
mp_routes = self.getRoutes(mp_URL_email, route_ids)
for route in mp_routes['routes']:
pos += 1
gpxinstance.waypoints.append(
gpx.GPXWaypoint(Decimal(str(route['latitude'])),
Decimal(str(route['longitude'])),
name=route['name'] + ' - ' +
route['rating'],
description=route['url']))
return gpxinstance.to_xml()
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 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 getMP_GPX_location(self, lat, lng, maxDistance, minDiff, maxDiff):
gpxinstance = gpx.GPX()
mp_routes = self.getRoutesForLatLong(lat, lng, maxDistance, minDiff,
maxDiff)
for route in mp_routes['routes']:
gpxinstance.waypoints.append(
gpx.GPXWaypoint(Decimal(str(route['latitude'])),
Decimal(str(route['longitude'])),
name=route['name'] + ' - ' + route['rating'],
description=route['url']))
return gpxinstance.to_xml()
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 export(self):
if self.rows:
# create a new gpx file
gpx_data = gpx.GPX()
# exclude rows with no centroid data (polylines at present)
to_gpx = (rw for rw in self.rows if rw.centroid_x is not None)
# add the centroids into the file
for pt in to_gpx:
gpx_data.waypoints.append(
gpx.GPXWaypoint(name=pt.location,
longitude=pt.centroid_x,
latitude=pt.centroid_y))
return gpx_data.to_xml()
else:
return ''
def Convert(utm_file, gpx_file, zone):
gpx_obj = gpx.GPX()
route = gpx.GPXRoute(name='UTM route')
gpx_obj.routes.append(route)
for line in utm_file:
m = UTM_RE.match(line[:-1]) # strip trailing \n
if not m:
raise MalformedLineException(line)
lat, lng = utm.to_latlon(int(m.group('easting')),
int(m.group('northing')), zone.number,
zone.letter)
route.points.append(
gpx.GPXRoutePoint(lat,
lng,
name=m.group('id'),
description=m.group('description')))
gpx_file.write(gpx_obj.to_xml())
gpx_file.write('\n') # terminating newline not written by default
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_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 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 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)
def __init__(self):
self.gpx_file = gpx.GPX()
self.current_track = None
self.current_segment = None
self._is_started = False
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
mp_profile = getMP_API(profile_url)
print('Getting MP ToDo List for', mp_profile['name'])
todos_url = getMP_URL(mp_URL_base, 'get-to-dos', mp_URL_email, mp_private_key)
mp_todos = getMP_API(todos_url)
#get routes returns an array of integer route Ids, make a string to pass to MP
route_ids = ','.join(str(todo) for todo in mp_todos['toDos'])
if len(route_ids) > 0:
#return routes
routes_url = getMP_URL(mp_URL_base, 'get-routes', mp_URL_email,
mp_private_key)
routes_url = str.format("{0}&routeIds={1}", routes_url, route_ids)
mp_routes = json_str = getMP_API(routes_url)
gpxinstance = gpx.GPX()
for route in mp_routes['routes']:
gpxinstance.waypoints.append(
gpx.GPXWaypoint(Decimal(str(route['latitude'])),
Decimal(str(route['longitude'])),
name=route['name'] + ' - ' + route['rating'],
description=route['url']))
#write to file
fo = open(r"todos.gpx", "w+")
fo.write(gpxinstance.to_xml())
print('Success: Created GPX File: todos.gpx')
