def write_gpx(gpx, name, act_type):
# You can add routes and waypoints, too...
tzname = None
npoints = None
# polyline encoder default values
numLevels = 18
zoomFactor = 2
epsilon = 0.0
forceEndpoints = True
##print('Created GPX:', gpx.to_xml())
ts = int(time.time())
filename = "%s/%i.gpx" % (filebase, ts)
a = open(filename, "w")
a.write(gpx.to_xml())
a.close()
gpx.simplify()
# gpx.reduce_points(1000)
trk = pl.read_gpx_trk(gpx.to_xml(), tzname, npoints, 2, None)
try:
polyline = pl.print_gpx_google_polyline(trk, numLevels, zoomFactor, epsilon, forceEndpoints)
except UnboundLocalError as er:
print(er)
print("Not enough points to create a polyline")
polyline = ""
# polyline="polyline"
add_run(gpx, name, act_type, filename, polyline)
def write_gpx(gpx,name,act_type):
# You can add routes and waypoints, too...
tzname=None
npoints=None
# polyline encoder default values
numLevels = 18;
zoomFactor = 2;
epsilon = 0.0;
forceEndpoints = True;
##print('Created GPX:', gpx.to_xml())
ts = int(time.time())
filename = "%s/%i.gpx" % (filebase,ts)
a = open(filename, 'w')
a.write(gpx.to_xml())
a.close()
gpx.simplify()
#gpx.reduce_points(1000)
trk = pl.read_gpx_trk(gpx.to_xml(),tzname,npoints,2,None)
try:
polyline=pl.print_gpx_google_polyline(trk,numLevels,zoomFactor,epsilon,forceEndpoints)
except UnboundLocalError as er:
print(er)
print("Not enough points to create a polyline")
polyline=""
#polyline="polyline"
add_run(gpx,name,act_type,filename,polyline)
def main():
args = parse_args()
with open(args.route_filename, 'r') as fp:
route = json.load(fp)
timezone = args.timezone and pytz.timezone(args.timezone) or None
gpx = convert(route, timezone)
if args.creator:
gpx.creator = args.creator
print gpx.to_xml()
def saveGPX(gpx, fn):
if debugging:
print('Created GPX:', gpx.to_xml())
waypoints = len(gpx.waypoints)
if waypoints == 0:
print(f'GPX with {str(waypoints)} waypoints SKIPPED: {fn}')
return
f = open(fn, "w")
f.write(gpx.to_xml())
f.close()
print(f'GPX with {str(waypoints)} points exported to {fn}')
def gen_gpx(list):
gpx = gpxpy.gpx.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:
for i in list:
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(i["y"], i["x"]))
print gpx.to_xml()
def gamepadStuff():
gpsData = readFromNav()
if gpsData:
print("gpsData", gpsData)
global gpsSpeed
gpsSpeed['text'] = "{:.9f}".format(3.6 * gpsData["speed"])
print(gpsSpeed['text'])
global chokeIsOn
if (not chokeIsOn):
for event in pygame.event.get():
if event.type == pygame.JOYBUTTONDOWN:
print("Joystick button pressed.", event.dict['button'])
if (event.dict['button'] == 15):
print("Starting new GPX file")
print('Created GPX:', gpx.to_xml())
timestr = time.strftime("%Y%m%d-%H%M%S")
with open("gpslog" + timestr + ".xml", "a") as text_file:
print(gpx.to_xml(), file=text_file)
elevationValue = 0
createGpxTrack()
if event.type == pygame.JOYBUTTONUP:
print("Joystick button released.")
#Brake
value = ((jStick.get_axis(12) * 100) + 100) / 2
scale3.set(int(round(value)))
value = 375 - (value) * 2.25
brakeValue(str(+int(round(value))))
#Speed
#441 max
# 150 min
value = ((jStick.get_axis(13) * 100) + 150) / 2
scale2.set(int(round(value)))
value = (value) + 350
speedValue(str(+int(round(value))))
#Steer:
#300 Min
#445 Max
value = ((jStick.get_axis(0) * 100)) / 2
scale.set(int(round(value)))
value = (value + 50) * 1.45 + 300
steerValue(str(+int(round(value))))
root.after(50, gamepadStuff)
return
else:
toSet = chokeMinValue + randint(15, 35)
scale2.set(toSet)
sock.sendto(
bytes('speed:' + str((chokeMinValue + toSet) + 350), 'UTF-8'),
server_address)
root.after(200, gamepadStuff)
def gamepadStuff():
gpsData = readFromNav()
if gpsData:
print("gpsData", gpsData)
global gpsSpeed
gpsSpeed['text'] = "{:.9f}".format(3.6 * gpsData["speed"])
print(gpsSpeed['text'])
global chokeIsOn
if(not chokeIsOn):
for event in pygame.event.get():
if event.type == pygame.JOYBUTTONDOWN:
print("Joystick button pressed." , event.dict['button'])
if(event.dict['button'] == 15):
print("Starting new GPX file")
print('Created GPX:', gpx.to_xml())
timestr = time.strftime("%Y%m%d-%H%M%S")
with open("gpslog"+ timestr + ".xml", "a") as text_file:
print(gpx.to_xml(), file=text_file)
elevationValue = 0
createGpxTrack()
if event.type == pygame.JOYBUTTONUP:
print("Joystick button released.")
#Brake
value = ((jStick.get_axis(12) * 100)+ 100) / 2
scale3.set(int(round(value)))
value = 375 - (value)*2.25
brakeValue(str(+int(round(value))))
#Speed
#441 max
# 150 min
value = ((jStick.get_axis(13) * 100) +150) / 2
scale2.set(int(round(value)))
value = (value) + 350
speedValue(str(+int(round(value))))
#Steer:
#300 Min
#445 Max
value = ((jStick.get_axis(0) * 100)) / 2
scale.set(int(round(value)))
value = (value+50)*1.45 + 300
steerValue(str(+int(round(value))))
root.after(50, gamepadStuff)
return
else:
toSet = chokeMinValue + randint(15,35)
scale2.set(toSet)
sock.sendto(bytes('speed:'+ str((chokeMinValue + toSet) +350),'UTF-8'), server_address)
root.after(200, gamepadStuff)
def to_gpx(self):
self.images = sorted(self.images, key=lambda i: i.datetime)
gpx = gpxpy.gpx.GPX()
track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(track)
prev_image = None
current_segment = gpxpy.gpx.GPXTrackSegment()
track.segments.append(current_segment)
for img in self.images:
print(img.datetime, img.lat, img.lng)
point = gpxpy.gpx.GPXTrackPoint(img.lat, img.lng, time=img.datetime)
if prev_image is not None:
if prev_image.datetime.date() != img.datetime.date():
self.logger.debug("new day => new segment")
current_segment = gpxpy.gpx.GPXTrackSegment()
track.segments.append(current_segment)
prev_image = img
current_segment.points.append(point)
return gpx.to_xml()
def downloader(activityID, filename): r = requests.get(STRAVA_STREAM_URL + activityID, params=DATA) json_track = json.loads(r.text) gpx = gpxpy.gpx.GPX() # 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) for latlng, altitude in list(zip(json_track['latlng'], json_track['altitude'])): gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint( latlng[0], latlng[1], elevation=altitude)) filename = filename if '.gpx' in filename else filename + '.gpx' with open(filename, 'w') as fw: fw.write(gpx.to_xml()) fw.close()
def get_gpx(id):
uri = f'https://data.gouv.nc/api/records/1.0/search/?dataset=sentiers-de-randonnee-en-province-sud&fields=id,title,description,tracewkt&rows=1&q=id%3D{id}'
res = requests.get(uri, headers={'Authorization': f'Apikey {APIKEY}'})
randonnee = res.json()['records'][0]['fields']
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for point in randonnee['tracewkt']['coordinates']:
longitude, latitude = point
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(latitude, longitude))
return app.response_class(response=json.dumps({
'id':
randonnee['id'],
'title':
randonnee['title'],
'description':
randonnee['description'],
'gpx':
gpx.to_xml()
}),
status=200,
mimetype='application/json')
def trans(self , route ):
points = route["data"]["points"]
# Calculate offset of start point
lat = points[0]["latitude"]
lon = points[0]["longitude"]
realoffset = self.justifyCityOffset( float(lat) ,float(lon) )
print realoffset
gpx = gpxpy.gpx.GPX()
# Create route in our GPX:
gpx_route = gpxpy.gpx.GPXRoute()
i = 1
for p in points:
tmpname = "#%5d" % i
tmptime = strptime( p["time_stamp"] , DATE_FORMAT )
lat = float(p["latitude"]) + float(realoffset[0])
lon = float(p["longitude"]) + float(realoffset[1])
gpx_point = gpxpy.gpx.GPXRoutePoint( name = tmpname , longitude = lon , latitude = lat ,
elevation = p["elevation"] , time = tmptime )
# print gpx_point
gpx_route.points.append( gpx_point )
i = i + 1
gpx.routes.append(gpx_route)
# print 'Created GPX:', gpx.to_xml()
return gpx.to_xml()
def leave(gpx):
global info_display
filename = str(round(time.time() * 1000))
os.system('clear')
print('\nGPX file Created : ' + filename + ".gpx")
file = open("/home/phablet/Downloads/" + filename + ".gpx", "w+")
file.write(gpx.to_xml())
file.close()
gpx_file = "/home/phablet/Downloads/" + filename + ".gpx"
shutil.chown(gpx_file, user="******", group="phablet")
gpx = gpxpy.parse(open(gpx_file))
indentation = ' '
info_display = ""
length_2d = gpx.length_2d()
length_3d = gpx.length_3d()
info_display += "\n%sLength 2D: %s" % (indentation, format_long_length(length_2d))
info_display += "\n%sLength 3D: %s" % (indentation, format_long_length(length_3d))
moving_time, stopped_time, moving_distance, stopped_distance, max_speed = gpx.get_moving_data()
info_display += "\n%sMoving time: %s" %(indentation, format_time(moving_time))
info_display += "\n%sStopped time: %s" %(indentation, format_time(stopped_time))
info_display += "\n%sMax speed: %s" % (indentation, format_speed(max_speed))
info_display += "\n%sAvg speed: %s" % (indentation, format_speed(moving_distance / moving_time) if moving_time > 0 else "?")
uphill, downhill = gpx.get_uphill_downhill()
info_display += "\n%sTotal uphill: %s" % (indentation, format_short_length(uphill))
info_display += "\n%sTotal downhill: %s" % (indentation, format_short_length(downhill))
info_display += "\n\n\n"
print(info_display)
if args.activity:
newlocation="/home/phablet/.local/share/activitytracker.cwayne18/{}".format(filename + ".gpx")
copyfile(gpx_file, newlocation)
shutil.chown(newlocation, user="******", group="phablet")
add_run(gpx,filename,"", newlocation)
p.kill()
sys.exit()
def make_gpx_from_points(title, points_dict_list):
gpx = gpxpy.gpx.GPX()
gpx.nsmap[
"gpxtpx"] = "http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
gpx_track = gpxpy.gpx.GPXTrack()
gpx_track.name = title
gpx_track.type = "Run"
gpx.tracks.append(gpx_track)
# Create first segment in our GPX track:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for p in points_dict_list:
if p.get("heart_rate") is None:
point = gpxpy.gpx.GPXTrackPoint(**p)
else:
heart_rate_num = p.pop("heart_rate")
point = gpxpy.gpx.GPXTrackPoint(**p)
gpx_extension_hr = ElementTree.fromstring(
f"""<gpxtpx:TrackPointExtension xmlns:gpxtpx="http://www.garmin.com/xmlschemas/TrackPointExtension/v1">
<gpxtpx:hr>{heart_rate_num}</gpxtpx:hr>
</gpxtpx:TrackPointExtension>
""")
point.extensions.append(gpx_extension_hr)
gpx_segment.points.append(point)
return gpx.to_xml()
def CreateTrack(gliderName, lat, lon, **kwargs):
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
#gpx_track = gpxpy.gpx.GPXTrack()
#gpx.tracks.append(gpx_track)
# Create first segment in our GPX track:
gpx_last_waypoint = gpxpy.gpx.GPXWaypoint(
lat, lon, 0, datetime.datetime.today(), gliderName,
'GliderLocation from Dockserver')
gpx.waypoints.append(gpx_last_waypoint)
if kwargs.has_key('wpt_lat') and kwargs.has_key('wpt_lon'):
wpt_lat, wpt_lon = kwargs['wpt_lat'], kwargs['wpt_lon']
gpx_aim_waypoint = gpxpy.gpx.GPXWaypoint(wpt_lat, wpt_lon)
gpx.waypoints.append(gpx_aim_waypoint)
#gpx_segment = gpxpy.gpx.GPXTrackSegment()
#gpx_track.segments.append(gpx_segment)
# Create points:
#gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1234, 5.1234, elevation=0))
#gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1235, 5.1235, elevation=0))
#gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1236, 5.1236, elevation=0))
# You can add routes and waypoints, too...
return gpx.to_xml()
def write_combined_track(self):
"Write all database tracks to one GPX file"
gpx = gpxpy.gpx.GPX()
tracks = self.database.cursor()
tracks.execute('''select _id, trackfolder, trackname, trackdescr from tracks
order by trackfolder, _id''')
for row in tracks:
track_id = row['_id']
track_name = row['trackname']
track_description = row['trackdescr']
track_folder = row['trackfolder']
print('Exporting track {} / {}'.format(track_folder, track_name))
if not track_folder == '' and not track_folder == '---':
track_name = '{} - {}'.format(track_folder, track_name)
self.add_track_to_gpx(track_id, track_name, track_description, gpx)
tracks.close()
try:
with open(self.output_file, 'w', encoding='utf-8') as file:
file.write(gpx.to_xml())
except OSError as ex:
print('Error: Cannot write file {}: {} - using track-ID as name'.
format(self.output_file, ex))
def generate_gpx(*args, **kwargs):
args = dict(request.args)
if 'trip_name' not in args and 't' not in args:
return bad_request_error_handler(NameError(f'Key trip_name not found'))
trip_name = ''.join((args.get('trip_name', None) or args['t']))
waypoints = get_waypoints_by_trip(trip_name)
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for i in range(len(waypoints)):
id, fms_key_id, id_fms, lat, long, alt, ts, bs, msg = waypoints[i]
ts = str_ts_to_UTC_ts(ts)
if msg:
ts_msg = ts.astimezone(timezone(offset=timedelta(hours=+3))).strftime(" (%m-%d %H:%M)")
gpx.waypoints.append(gpxpy.gpx.GPXWaypoint(latitude=lat, longitude=long, elevation=alt, comment=msg + ts_msg, time=ts, name=msg + ts_msg))
cur_pnt = gpxpy.gpx.GPXTrackPoint(latitude=lat, longitude=long, elevation=alt, comment=msg, time=ts)
cur_pnt.description = f"Время: {ts} Заряд батареи {bs}"
gpx_segment.points.append(cur_pnt)
# Добавляем точку с временем последнего сообщения
if waypoints:
ts_msg = ts.astimezone(timezone(offset=timedelta(hours=+3))).strftime("%Y-%m-%d %H:%M:%S")
gpx.waypoints.append(gpxpy.gpx.GPXWaypoint(latitude=lat, longitude=long, elevation=alt, comment=ts_msg, time=ts, name=ts_msg))
hdrs = Headers()
hdrs.add('Content-Type', 'application/gpx+xml')
hdrs.add('Content-Disposition', 'attachment', filename='track.gpx')
return Response(gpx.to_xml(), headers=hdrs)
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 write_gpx(log_data: bytes, file_name: str) -> int:
try:
log = Locus(log_data)
except LocusError:
logger.warning("Log is blank. Not writing empty GPX file")
return 0
gpx = gpxpy.gpx.GPX()
# 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:
for point in log:
p = gpxpy.gpx.GPXTrackPoint(time=datetime.datetime.utcfromtimestamp(
point["utc_time"]),
latitude=point["latitude"],
longitude=point["longitude"],
elevation=point["height"])
# TODO: Use GPX 1.1 extensions for speed and heading, but which ones?
# {"nmea:speed": point["speed"] * 3.6 / 1.852}
# {"nmea:heading": point["heading"]}
gpx_segment.points.append(p)
with open(file_name, "w") as f:
f.write(gpx.to_xml(version="1.1"))
return 0
def download(downId):
# connect to database
dbDown=mdb.connect(host="mysql.server",user="******", \
db=dbName,passwd="you-wish")
curDown=dbDown.cursor()
curDown.execute("SELECT MapMyRunId, Lat, Lng FROM Points WHERE MapMyRunId = %s", (downId))
query_results=curDown.fetchall()
path=[]
for result in query_results:
path.append(dict(id=result[0],lat=result[1],lng=result[2]))
# setup gpx file
gpx = gpxpy.gpx.GPX()
# create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack()
gpx_track.name = 'test'
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
# write route points to gpx file
points_count = len(path)
points_range = range(points_count)
for point_num in points_range:
point = path[point_num]
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(point['lat'], point['lng']))
# gpx is essentially xml format, so form proper response
response = make_response(gpx.to_xml())
response.headers["Content-Disposition"] = "attachment; filename=route.gpx"
return response
def gen_gpx(gpx_points):
gpx = gpxpy.gpx.GPX()
gpx.nsmap[
"gpxtpx"] = "http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
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)
file_name = gpx_points[0].get("start_time")
for p in gpx_points:
# delete useless attr
del p["start_time"]
if p.get("heart_rate") is None:
point = gpxpy.gpx.GPXTrackPoint(**p)
else:
heart_rate_num = p.pop("heart_rate")
point = gpxpy.gpx.GPXTrackPoint(**p)
gpx_extension_hr = ElementTree.fromstring(
f"""<gpxtpx:TrackPointExtension xmlns:gpxtpx="http://www.garmin.com/xmlschemas/TrackPointExtension/v1">
<gpxtpx:hr>{heart_rate_num}</gpxtpx:hr>
</gpxtpx:TrackPointExtension>
""")
point.extensions.append(gpx_extension_hr)
gpx_segment.points.append(point)
return gpx.to_xml(), file_name
def create_gpx(activity_meta):
activity_ids = activity_meta['id']
# types = ['time', 'distance', 'latlng', 'altitude', 'velocity_smooth', 'moving', 'grade_smooth', 'heartrate']
types = ['time', 'latlng', 'altitude']
for thisid in activity_ids:
activity_data = client.get_activity_streams(thisid, types=types)
# get start time for this activity
starttime = activity_meta[activity_meta['id'] ==
thisid]['start_date'].values[0]
### Create gpx output
gpx = gpxpy.gpx.GPX()
# 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)
for i in range(len(activity_data['time'].data)):
lat = activity_data['latlng'].data[i][0]
lon = activity_data['latlng'].data[i][1]
ele = activity_data['altitude'].data[i]
ts = pd.to_datetime(starttime) + datetime.timedelta(
0, activity_data['time'].data[i])
gpx_segment.points.append(
gpxpy.gpx.GPXTrackPoint(lat, lon, elevation=ele, time=ts))
filename = "strava_id_" + str(thisid) + ".gpx"
with open(filename, "w") as f:
f.write(gpx.to_xml())
print("Generated file " + filename)
def get_gpx(request, track_id):
tracks = Track.objects.all()
if not request.user.is_authenticated:
tracks = Track.objects.filter(public=True)
track = get_object_or_404(tracks, id=track_id)
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack(name=track.name)
gpx.tracks.append(gpx_track)
segments = Segment.objects.filter(track=track)
for segment in segments:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
points = Point.objects.filter(segment=segment).order_by('date')
for point in points:
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(
point.latitude,
point.longitude,
elevation=point.altitude,
time=point.date
))
gpx_track.segments.append(gpx_segment)
return HttpResponse(gpx.to_xml(), content_type="application/gpx+xml")
def write_gpx(log_data: bytes, file_name: str) -> int:
log = decode_gps_log(log_data)
if log is None:
logger.warning("Log is blank. Not writing empty GPX file")
return 0
gpx = gpxpy.gpx.GPX()
# 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:
for point in log["waypoints"]:
p = gpxpy.gpx.GPXTrackPoint(
latitude=point["latitude"],
longitude=point["longitude"],
elevation=point["elevation"],
time=point["utc_time"],
)
# TODO: Use GPX 1.1 extensions for speed and heading, but which ones?
# {"nmea:speed": point["speed"] * 3.6 / 1.852}
# {"nmea:heading": point["heading"]}
gpx_segment.points.append(p)
with open(file_name, "w") as f:
f.write(gpx.to_xml(version="1.1"))
return 0
def update_downloader(eps, npts, idx_cluster, relayoutData):
mdf, lat0, lon0, zoom0 = filter_data(relayoutData)
d = get_dbscan_data(mdf, eps, npts)
tmp = d[d["cluster"] == idx_cluster]
gpx = gpxpy.gpx.GPX()
# 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)
for index, row in tmp.iterrows():
lat = row["Lat"]
lon = row["Lon"]
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(lat, lon))
gpxString = "data:text/csv;charset=utf-8," + urllib.parse.quote(
gpx.to_xml())
return gpxString
def create_gpx(activities):
# get point from activities
for activity in activities:
generatedName = USERNAME + "-" + str(uuid.uuid4())[:8] + str(
uuid.uuid4())[:5]
filename = "gpx/tmp/" + generatedName + ".gpx"
points = polyline.decode(activity['map']['summary_polyline'])
# init gpx file
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for point in points:
gpx_segment.points.append(
gpxpy.gpx.GPXTrackPoint(point[0], point[1]))
file = open(filename, "w")
file.write(gpx.to_xml())
file.close()
cursor = DB.cursor()
sql = "INSERT INTO tmp_gpx (name, user_id) VALUES (%s,%s)"
cursor.execute(sql, (generatedName, USER_ID))
DB.commit()
def handle(self, *args, **options):
session = requests.Session()
# access_token = ''
# params = {
# 'access_token': access_token,
# 'geometries': 'geojson',
# 'overview': 'full'
# }
# for service in Service.objects.filter(operator='LYNX', current=True):
# print(service)
# linestrings = (self.get_linestring(session, access_token, params, ls) for ls in service.geometry)
# linestrings = (ls for ls in linestrings if ls)
# service.geometry = MultiLineString(*linestrings).simplify()
# service.save()
for service in Service.objects.filter(current=True, operator='SNDR'):
stopses = set()
for file in service.get_files_from_zipfile():
timetable = txc.Timetable(file)
for grouping in timetable.groupings:
for journeypattern in grouping.journeypatterns:
stop_ids = [journeypattern.sections[0].timinglinks[0].origin.stop.atco_code]
for section in journeypattern.sections:
for timinglink in section.timinglinks:
stop_ids.append(timinglink.destination.stop.atco_code)
stopses.add(','.join(stop_ids))
stopses = [string.split(',') for string in stopses]
linestrings = []
for stop_ids in stopses:
stops = StopPoint.objects.in_bulk((stop_ids))
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for stop_id in stop_ids:
stop = stops[stop_id]
point = gpxpy.gpx.GPXTrackPoint(stop.latlong.y, stop.latlong.x)
gpx_segment.points.append(point)
xml = gpx.to_xml()
response = session.post('https://bustimes.org/match?type=json&points_encoded=false',
headers={'Content-Type': 'application/gpx+xml'},
data=xml)
if response.ok:
json = response.json()
if json['map_matching']['distance']:
geometry = json['paths'][0]['points']
linestrings.append(GEOSGeometry(str(geometry)))
service.geometry = MultiLineString(*linestrings)
service.save()
print(service.pk)
def process_and_save(input_file_path, new_time, new_filename):
gpx_file = open(input_file_path, 'r')
gpx = gpxpy.parse(gpx_file)
delta = relativedelta(new_time, gpx.time)
gpx.adjust_time(delta)
with open(new_filename, 'w') as f:
f.write(gpx.to_xml())
def to_gpx(self):
if self.point_file != None and os.path.isfile(self.point_file):
st = os.stat(self.point_file)
print("{0:s}, size {1:d}".format(self.point_file, st.st_size))
df = pd.read_csv(self.point_file,
sep=",",
header=None,
names=["x", "y", "name"],
dtype={
"x": np.object,
"y": np.object,
"name": np.object
})
#
# with open(self.point_file, "r", encoding='utf8') as f:
# rows = list(csv.reader(f))
gpx = gpxpy.gpx.GPX()
for index, r in df.iterrows():
if len(r) != 0:
x1, y1, name = r['x'].strip(), r['y'].strip(
), r['name'].strip()
print("x1={},y1={}, name={}".format(x1, y1, name))
x1, y1 = normalize(x1, y1)
print("{},{}, name={}".format(x1, y1, name))
'''
In fact, the ll supported by all GPS tool (ex. Map Generation Tool) is based wgs84 rather than twd67
Can't correctly shows the ll if only change change coordination format
'''
x3, y3 = pyproj.transform(crs_twd67, crs_wgs84, x1, y1)
print("{:5.8f},{:5.8f}, name={}".format(y3, x3, name))
# wp = GPXWaypoint(longitude=x3, latitude=y3, name=name, elevation="0.0", time=datetime.now(),
# symbol="Waypoint")
wp = GPXWaypoint(longitude=x3,
latitude=y3,
name=name,
elevation="0.0",
time=np.datetime64("now").astype(object),
symbol="Waypoint")
gpx.waypoints.append(wp)
# print(gpx.to_xml())
name = os.path.splitext(
self.point_file
)[0] + ".gpx" # rename the source file with .gpx extension
path = os.path.abspath(self.point_file)
gpx_file = os.path.join(path, name)
print("writing xml to {}".format(gpx_file))
with open(gpx_file, "w+", encoding='utf8') as f:
f.write(gpx.to_xml(version="1.1"))
print("done")
def clean_gpx_file(file_name):
# file_name : gpx_file(with complete path)
# return : name of created file
# at this stage, due to have n/a fields we cannot use 'pygpx' to open this file
# replace n/a with 0
fin = open(file_name, "rt")
data = fin.read()
fin.close()
data = data.replace('n/a', '0')
fout = open(file_name, "wt")
fout.write(data)
fout.close()
# read the file with gpxpy
gpx_file = open(file_name, 'r')
gpx = gpxpy.parse(gpx_file)
# find 0 lat/lon fields and fill them by
# interpolate between geometries around them
wpts_len = len(gpx.waypoints)
wpts = gpx.waypoints
i = 1
last_valid_lat = float(wpts[0].latitude)
last_valid_lon = float(wpts[0].longitude)
while i < wpts_len:
j = 1
lat_1 = float(wpts[i].latitude)
lon_1 = float(wpts[i].longitude)
if lat_1 == 0:
lat_2 = 0
lon_2 = 0
while (j + i) < wpts_len and lat_2 == 0:
lat_2 = float(wpts[i + j].latitude)
lon_2 = float(wpts[i + j].longitude)
j += 1
lat_offset = (lat_2 - last_valid_lat) / j
lon_offset = (lon_2 - last_valid_lon) / j
for k in range(j - 1):
gpx.waypoints[k + i].latitude = str(last_valid_lat +
(k + 1) * lat_offset)
# print(gpx1.waypoints[k+i].latitude, k)
gpx.waypoints[k + i].longitude = str(last_valid_lon +
(k + 1) * lon_offset)
# print(gpx1.waypoints[i+1].latitude,i)
last_valid_lat = lat_2
last_valid_lon = lon_2
else:
last_valid_lat = lat_1
last_valid_lon = lon_1
i += j
# save new file
new_file = open(file_name[:-4] + '_cleaned.gpx', 'w')
new_file.write(gpx.to_xml())
new_file.close()
# remove last file
gpx_file.close()
os.remove(file_name)
return file_name[:-4] + '_cleaned.gpx'
def generate(self):
gpx = gpxpy.gpx.GPX()
gpx.name = self.tour["name"]
gpx.description = f"Distance: {str(int(self.tour['distance']) / 1000.0)}km, " \
f"Estimated duration: {str(round(self.tour['duration'] / 3600.0, 2))}h, " \
f"Elevation up: {self.tour['elevation_up']}m, " \
f"Elevation down: {self.tour['elevation_down']}m, " \
f"Grade: {self.tour['difficulty']['grade']}"
gpx.author_name = self.tour["_embedded"]["creator"]["display_name"]
gpx.author_link = "https://www.komoot.de/user/" + str(
self.tour["_embedded"]["creator"]["username"])
gpx.author_link_text = "View " + gpx.author_name + "'s Profile on Komoot"
gpx.link = "https://www.komoot.de/tour/" + str(self.tour["id"])
gpx.link_text = "View tour on Komoot"
gpx.creator = self.tour["_embedded"]["creator"]["display_name"]
track = gpxpy.gpx.GPXTrack()
track.name = gpx.name
track.description = gpx.description
track.link = gpx.link
track.link_text = gpx.link_text
track.link_type = gpx.link_type
gpx.tracks.append(track)
segment = gpxpy.gpx.GPXTrackSegment()
track.segments.append(segment)
for coord in self.route:
point = gpxpy.gpx.GPXTrackPoint(coord.lat, coord.lng)
if coord.alt != coord.CONST_UNDEFINED:
point.elevation = coord.alt
if coord.time != coord.CONST_UNDEFINED:
point.time = datetime.fromtimestamp(coord.time / 1000)
segment.points.append(point)
if not self.no_poi:
for poi in self.pois:
wp = gpxpy.gpx.GPXWaypoint(poi.point.lat, poi.point.lng)
if poi.point.alt != poi.point.CONST_UNDEFINED:
wp.elevation = poi.point.alt
if poi.point.time != poi.point.CONST_UNDEFINED:
wp.time = datetime.fromtimestamp(poi.point.time / 1000)
wp.name = poi.name
wp.description = poi.description
wp.source = "Komoot"
wp.link = poi.url
wp.link_text = "View POI on Komoot"
wp.type = poi.type
wp.comment = poi.image_url
gpx.waypoints.append(wp)
return gpx.to_xml()
def trans(self , route , type = "track"):
name = route["data"]["start_time"]
points = route["data"]["points"]
# Calculate offset of start point
lat = points[0]["latitude"]
lon = points[0]["longitude"]
realoffset = self.justifyCityOffset( float(lat) ,float(lon) )
print realoffset
gpx = gpxpy.gpx.GPX()
if type == "route":
# Create route in GPX Route Format:
rtname = "Route %s" % name
gpx_route = gpxpy.gpx.GPXRoute(name = rtname)
i = 1
for p in points:
tmpname = "#%5d" % i
tmptime = strptime( p["time_stamp"] , DATE_FORMAT )
lat = float(p["latitude"]) + float(realoffset[0])
lon = float(p["longitude"]) + float(realoffset[1])
gpx_point = gpxpy.gpx.GPXRoutePoint( name = tmpname , longitude = lon , latitude = lat ,
elevation = p["elevation"] , time = tmptime )
# print gpx_point
gpx_route.points.append( gpx_point )
i = i + 1
gpx.routes.append(gpx_route)
else:
# Create route in GPX Track Format:
trkname = "Track %s" % name
gpx_track = gpxpy.gpx.GPXTrack(name = trkname)
gpx_track_seg = gpxpy.gpx.GPXTrackSegment()
i = 1
for p in points:
tmpname = "#%5d" % i
tmptime = strptime( p["time_stamp"] , DATE_FORMAT )
lat = float(p["latitude"]) + float(realoffset[0])
lon = float(p["longitude"]) + float(realoffset[1])
gpx_point = gpxpy.gpx.GPXTrackPoint( name = tmpname , longitude = lon , latitude = lat ,
elevation = p["elevation"] , time = tmptime )
# print gpx_point
gpx_track_seg.points.append( gpx_point )
i = i + 1
gpx_track.segments.append(gpx_track_seg)
gpx.tracks.append(gpx_track)
# print 'Created GPX:', gpx.to_xml()
return gpx.to_xml()
def save_gpx(file, tracks):
gpx = gpxpy.gpx.GPX()
for t in tracks:
g = t.as_gpxpy
if isinstance(g, gpxpy.gpx.GPXWaypoint):
gpx.waypoints.append(g)
else:
gpx.tracks.append(g)
with open(file, "w") as fh:
print(fh, gpx.to_xml())
def tupsToGpx(tups):
gpx = gpxpy.gpx.GPX()
# 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:
for pt in tups:
gpx_segment.points.append(
gpxpy.gpx.GPXTrackPoint(pt[0], pt[1], elevation=0))
# You can add routes and waypoints, too...
print 'Created GPX:', gpx.to_xml()
return gpx.to_xml()
def save_gpx(gpx, filename, dry_run):
"""Save this GPX with the same name in a new subdirectory"""
subdir = Path("split")
new_filename = subdir.joinpath(Path(filename))
if not dry_run:
new_filename.parent.mkdir(parents=True, exist_ok=True)
with open(new_filename, "w") as f:
f.write(gpx.to_xml())
print(colored(new_filename, "green"))
def create_gpx_track(data):
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
[
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(point[1], point[0]))
for point in data
]
return gpx.to_xml()
def main():
"""
Main function to do the work
"""
#
# Handle CLI args
#
parser = argparse.ArgumentParser(description=('Take a directory of GPS tagged'
' images and output GPX track'))
parser.add_argument('-d', '--directory', default=[], action='append',
required=True, type=is_directory,
help='Which directory of images to process. Repeat to '
'process multiple directories.')
parser.add_argument('--debug', default=False, action='store_true',
help='Enable additional output')
parser.add_argument('-l', '--log-level', action='store', required=False,
choices=["debug", "info", "warning", "error", "critical"],
default=DEFAULT_LOG_LEVEL,
help='Logging verbosity. Default: {}'.format(DEFAULT_LOG_LEVEL))
args = parser.parse_args()
# Enable the debug level logging when in debug mode
if args.debug:
args.log_level = 'debug'
# Configure logging
logging.basicConfig(format='%(levelname)s:%(module)s.%(funcName)s:%(message)s',
level=getattr(logging, args.log_level.upper()))
_get_logger().info("Log level is '%s'", args.log_level.upper())
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
for directory in args.directory:
# Create a segment in our GPX track:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
track = process_directory(directory)
for track_time in sorted(track):
#pprint(track[track_time])
gpx_segment.points.append(track[track_time])
#pprint(track)
print(clean_output(gpx.to_xml()))
def convert_to_gpx(log_file, force=False):
print log_file + ' converting ...'
gpx_file = log_file + '.gpx'
if force is False and os.path.isfile(gpx_file):
print gpx_file + ' file exist, skip converting'
return
with open(log_file) as f:
content = f.read().splitlines()
for i, var in enumerate(content):
content[i] = var.split('\t')
gpx = gpxpy.gpx.GPX()
gpx_track_file_name = os.path.basename(log_file)
gpx_track = gpxpy.gpx.GPXTrack()
gpx_track.name = gpx_track_file_name
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
last_point_date_time = get_date_time('1970-01-01 00:00:00')
for i, v in enumerate(content):
if len(v) < 5:
continue
point_date_time = get_date_time(v[0])
delta = point_date_time - last_point_date_time
if i != 0 and delta.seconds > 60 * 10:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
last_point_date_time = point_date_time
lat = v[1][1:]
lon = v[2][1:]
elevation = v[3]
current_speed = v[4]
magnetic_variation = v[5]
point = gpxpy.gpx.GPXTrackPoint(lat, lon, elevation=elevation, time=point_date_time, speed=current_speed)
point.magnetic_variation = magnetic_variation
gpx_segment.points.append(point)
result = gpx.to_xml()
result_file = open(gpx_file, 'w')
result_file.write(result)
result_file.close()
print log_file + ' - done'
def buildGPXfromCoordinatesList(wfile,listMessages):
gpx = gpxpy.gpx.GPX()
name = 1
for msg in listMessages:
if msg != None:
try:
gpx_waypoint=gpxpy.gpx.GPXWaypoint(name=name, latitude=msg[0], longitude=msg[1])
gpx.waypoints.append(gpx_waypoint)
name += 1
except:
pass
wfile.write(gpx.to_xml().encode('utf-8'))
def join_gpx(first_track_start, second_track_start):
first_track_start = minutes_to_military(first_track_start)
second_track_start = minutes_to_military(second_track_start)
directory_name = 'tracks/'
saving_name = 'save/'
saving_directory = os.path.join(directory_name, saving_name)
#print "####", first_track_start, second_track_start
files =[]
for f in os.listdir(saving_directory):
files.append(f)
files.sort()
segments_to_delete = []
for f_prev, f, f_next in neighborhood(files):
filename = os.path.join(saving_directory, f)
file = open(filename, 'rb')
gpx_xml = file.read()
file.close()
gpx = gpxpy.parse(gpx_xml)
if f_next is not None:
filename_next = os.path.join(saving_directory, f_next)
file_next = open(filename_next, 'rb')
gpx_xml_next = file_next.read()
file_next.close()
gpx_next = gpxpy.parse(gpx_xml_next)
for track, track_next in zip(gpx.tracks, gpx_next.tracks):
for segment, segment_next in zip(track.segments, track_next.segments):
if segment.points[0].time.strftime("%H%M") == first_track_start and \
segment_next.points[0].time.strftime("%H%M") == second_track_start:
segment.join(segment_next)
#segments_to_delete.append(filename)
segments_to_delete.append(filename_next)
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
# Create first segment in our GPX track:
gpx_track.segments.append(segment)
open(filename, 'w').close()
fo = open(filename, "wb")
fo.write(gpx.to_xml())
fo.close()
for f in segments_to_delete:
os.remove(f)
def buildGPX(wfile,listNMEAMessages):
gpx = gpxpy.gpx.GPX()
name = 1
for msg in listNMEAMessages:
if msg != None:
try:
if msg.latitude != None and msg.longitude != None and msg.latitude != 0.0 and msg.longitude != 0.0:
gpx_waypoint=gpxpy.gpx.GPXWaypoint(name=name, latitude=msg.latitude, longitude=msg.longitude)
gpx.waypoints.append(gpx_waypoint)
name += 1
except:
pass
wfile.write(gpx.to_xml().encode('utf-8'))
def write_gpx(path, data):
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for point in data:
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(
point[1], point[2], elevation=point[3], time=point[0]))
with open(path, "w") as f:
f.write(gpx.to_xml())
def writeWaypoint(waypoint, base_name, **options):
gpxutils.applyDefaults(options)
if waypoint:
# Create new GPX file
gpx = gpxpy.gpx.GPX()
# Append waypoint
gpx.waypoints.append(waypoint)
keep = (not options['interactive']) or prompt('waypoint', waypoint.name, base_name, waypoint.time)
if keep:
outfile = createUniqueFile(base_name, 'wpt', waypoint.time, waypoint.name, **options)
with outfile.open('w') as output:
output.write(gpx.to_xml())
def process_item(self, item, spider):
#start time is always on the day at 12:00
start_time = datetime.strptime(item["date"], '%d-%B-%Y')
start_time = start_time + timedelta(hours=12)
#Create time object from duration
#print "duration %s " % (item["time"])
duration_sec = float(seconds(item["time"]))
#print "duration_sec %s" % duration_sec
#Count number of points, this to calculate timedelta for every point based on the speed
points = float(len(item["Lat"]))
#time delta at every point should be points / seconds
time_per_point_sec = (duration_sec / points)
time_per_point = round(time_per_point_sec * 1000,0) #in Milliseconds
#print int(time_per_point)
#create time object from it
time_delta = datetime.strptime(str(int(time_per_point)), '%f')
activityname = "Run at " + start_time.strftime('%d-%m-%Y')
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack(name=activityname)
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:
for i,lat in enumerate(item ["Lat"]):
#print "lat nr %s is %s " % (i , lat)
lng = item ["Lng"][i]
#print "lng nr %s is %s " % (i , lng)
start_time = start_time + timedelta(seconds=time_per_point_sec)
#elevation_data = mod_srtm.get_data()
#meter = elevation_data.get_elevation(lat,lng)
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(lat, lng, elevation=None, time=start_time ))
filename = "gps_track" + item["date"] + ".gpx"
print " number of points %s in file %s " % (points, filename)
file = open(filename, "w")
file.write(gpx.to_xml())
file.close()
def create_gpx(records): gpx = gpxpy.gpx.GPX() # 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: for record in records: gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(record['lat'], record['lon'], elevation=record['alt'],time=record['date'])) # You can add routes and waypoints, too... return gpx.to_xml()
def write_gpx(data):
gpx_file = open('/mnt/sdcard/test.gpx', 'w')
gpx = gpxpy.gpx.GPX()
# gpx = gpxpy.parse(gpx_file)
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(data.lat_dd, data.lon_dd, elevation=data.alt_m))
gpx_file.write(gpx.to_xml())
gpx_file.close()
def polyline_to_gpx(polyline = None):
if polyline == None:
raise Exception("Need a Google Polyline as parameter")
waypoints = None
try:
waypoints = PolylineCodec().decode(polyline)
except Exception as e:
raise Exception("Error decoding polyline. err: {}".format(e))
gpx = gpxpy.gpx.GPX()
gpx.creator = "Ride with gpxpy"
for point in waypoints:
lat, lon = point
gpx.waypoints.append(gpxpy.gpx.GPXWaypoint(lat, lon))
return gpx.to_xml()
def merge_tracks(tracks, output_file=None):
gpx = gpxpy.gpx.GPX()
for t in tracks:
gpx.tracks.append(t)
xml = gpx.to_xml()
# save output gpx file
if output_file:
directory = '/'.join(output_file.split('/')[0:-1])
print directory
if not os.path.exists(directory):
os.makedirs(directory)
f = open(output_file, 'w+')
f.write(xml)
f.close()
print 'Wrote to file: %s' % output_file
def gpx_from_design_matrix(design_matrix, labels, centroids, f_name):
# Output clusters
gpx = gpxpy.gpx.GPX()
for row in range(design_matrix.shape[0]):
start_cluster = design_matrix[row, 0]
start_centroid = centroids[start_cluster, :]
end_cluster = labels[row]
end_centroid = centroids[end_cluster, :]
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(start_centroid[0], start_centroid[1], name=str(start_cluster), symbol=str(start_cluster)))
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(end_centroid[0], end_centroid[1], name=str(end_cluster), symbol=str(end_cluster)))
with open(f_name, 'w') as out:
out.write(gpx.to_xml())
def gpx_create(list_of_runzi_points, name):
# Creating a new file:
# --------------------
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
gpx_track = gpxpy.gpx.GPXTrack()
gpx_track.name = name
gpx.tracks.append(gpx_track)
# Create first segment in our GPX track:
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for point in list_of_runzi_points:
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(point['latitude'], point['longitude'], time=point['time'],
elevation=point['elevation']))
# You can add routes and waypoints, too...
return gpx.to_xml()
def gpolyfiles2shp(pattern, ofname=None):
files = glob(pattern)
gpx = GpxRoute()
with ThreadPoolExecutor(max_workers=4) as pool:
futures2poly = {pool.submit(get_content, fname): fname for fname in files}
for future in as_completed(futures2poly):
fname = futures2poly[future]
print('Handling %r' % fname)
if future.exception() is not None:
print('%r generated an exception: %s' % (fname, future.exception()))
continue
pcodec = PolylineCodec()
polyxy = pcodec.decode(future.result())
gpx_route = new_gpx_route(polyxy, name=fname)
gpx.routes.append(gpx_route)
with open(ofname, 'wb') as ofile:
ofile.write(gpx.to_xml())
print(ofname)
def writeAndCreateNewFile(segment, base_name, track_name=None, **options):
gpxutils.applyDefaults(options)
if segment is not None and segment.get_points_no() > 1:
# Create new GPX file
gpx = gpxpy.gpx.GPX()
# Create first track in our GPX:
track = gpxpy.gpx.GPXTrack(name=track_name)
gpx.tracks.append(track)
# Add segment to our GPX track:
track.segments.append(segment)
time = segment.get_time_bounds().start_time
keep = (not options['interactive']) or prompt('track', track_name, base_name, time)
if keep:
outfile = createUniqueFile(base_name, 'trk', time, track_name, **options)
with outfile.open('w') as output:
output.write(gpx.to_xml())
# Return a new segment
return gpxpy.gpx.GPXTrackSegment()
def makegpx(self, filename):
gpx = gpxpy.gpx.GPX()
gpx_track = gpxpy.gpx.GPXTrack()
gpx.tracks.append(gpx_track)
gpx_segment = gpxpy.gpx.GPXTrackSegment()
gpx_track.segments.append(gpx_segment)
for coord in self.coords:
coordtime = datetime.strptime(self.data['startTime'], "%Y-%m-%d %H:%M:%S.%f") + timedelta(seconds=coord['timeOffset'])
#print coordtime
#print coord['latitude'], coord['longitude'], self.data['startTime'], coord['timeOffset']
gpx_segment.points.append(
gpxpy.gpx.GPXTrackPoint(
coord['latitude'],
coord['longitude'],
time=coordtime,
elevation=self.find_nearest_altitude(
coord['timeOffset'])['altitude']
)
)
with open(filename, 'w') as fp:
fp.write(gpx.to_xml())
def gpoly2gpx(ifname, output_dir=None, json_path='routes/route/polyline-definition/polyline'):
response = get_content(ifname)
pcodec = PolylineCodec()
item = get_item(response, json_path)
if item is None:
logging.error(
'Bad input from file {ifname}'
'`\n`--> response {response}'
.format(**locals()))
sys.exit(1)
polyxy = pcodec.decode(item)
gpx = GpxRoute()
gpx_route = new_gpx_route(polyxy)
gpx.routes.append(gpx_route)
fname, extension = splitext(ifname)
output_dir = output_dir or dirname(fname)
ofname = join(output_dir, '{}.gpx'.format(basename(fname)))
with open(ofname, 'wb') as ofile:
ofile.write(gpx.to_xml())
print(ofname)
def mergeTracksToFile(self, outputFile): if not outputFile: print 'No output file set' return False # create a merged file # save the file gpx = gpxpy.gpx.GPX() tracks = self.getMergedTracks() tracks = self.sortTracksByTime(tracks) for t in tracks: gpx.tracks.append(t) xml = gpx.to_xml() # save output gpx file f = open(outputFile, 'w+') f.write(xml) f.close() print 'Merged GPX file saved at: %s' % outputFile
for point in segment.points:
print 'Point at ({0},{1}) -> {2}'.format(point.latitude, point.longitude, point.elevation)
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.points:
print 'Point at ({0},{1}) -> {2}'.format(point.latitude, point.longitude, point.elevation)
# There are many more utility methods and functions:
# You can manipulate/add/remove tracks, segments, points, waypoints and routes and
# get the GPX XML file from the resulting object:
print 'GPX:', gpx.to_xml()
# Creating a new file:
# --------------------
gpx = gpxpy.gpx.GPX()
# 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:
if key_id != 1: newtimestamp = datetime.datetime.strptime(time_stmp, '%Y-%m-%d %H:%M:%S.%f') #print newtimestamp newertimestamp = time.mktime(newtimestamp.timetuple()) #print newertimestamp gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(lat, lon, elevation=alt, time=newtimestamp)) except sqlite3.Error, e: if con: con.rollback() print "Error %s:" % e.args[0] sys.exit(1) finally: if con: con.close() foo = gpx.to_xml() f = open(real_filename, 'w') f.write(foo) print 'Done.' if __name__ == "__main__": # call with 2 args, first is your DB, second is output filename (no type) main(sys.argv[1], sys.argv[2])
continue
row_time = millisec_to_time(int(row['time']))
timestamp = time_start + row_time
#coordinates += '''%s,%s ''' % (row["longitude"],row["latitude"])
gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(row["latitude"], row["longitude"], time=timestamp))
#gpx_folder = gpx_file.split('.')[0]
#if os.path.exists(gpx_folder) and os.path.isdir(gpx_folder):
# print gpx_folder, 'exists'
#else:
# os.mkdir(gpx_folder)
#gpx_path = os.path.join(gpx_folder,gpx_file)
gpx_writer = open(gpx_path,'w')
gpx_writer.write(gpx.to_xml())
gpx_writer.close()
# In[4]:
get_ipython().magic(u'pinfo gpxpy.gpx.GPXTrackPoint')
# In[ ]:
def createGPXFile(name,gpx): file = open(name+'.gpx','w') file.write(gpx.to_xml()) file.close() return
sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + "/gpxpy")
import gpxpy, gpxpy.gpx
url = "http://api.wikimapia.org/?function=box&bbox=" + sys.argv[1] + "&key=225F1176-F8C948A8-9334FE28-F51181B6-17749F78-D35641D3-789AD3AA-D7D26C75&count=100&disable=polygon&language=en"
thereArePlaces = True
gpx = gpxpy.gpx.GPX()
page = 1
while (thereArePlaces):
url = url + "&page=" + str(page)
xmlContent = urllib.urlopen(url, 'r').read()
tree = ET.fromstring(xmlContent)
places = tree.findall('place')
thereArePlaces = (len(places) != 0)
for place in places:
location = place.find('location')
gpx.waypoints.append(gpxpy.gpx.GPXWaypoint(location.find('lat').text, location.find("lon").text, name = place.find('name').text))
page = page + 1
print gpx.to_xml()
