def rotation_around_placemark(self, data, params, kml_doc): if type(data) is list: print("list") longitude = data[0] latitude = data[1] else: longitude = data.longitude latitude = data.latitude # spin around the data for aspect in range(0, 360, 10): kml_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(params[0]), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(float(longitude)), KML.latitude(float(latitude)), KML.altitude(params[1]), KML.heading(aspect), KML.tilt(params[2]), KML.range(params[3]), KML.altitudeMode("relativeToGround"), ) ) ) kml_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(1.0))) return kml_doc
def create_tour_doc(tour_doc, row, imageInterval): camHeight = row['Z'] longitude, latitude = myProj(row['X'], row['Y'], inverse = True) azimuth = row['azimuth'] zenith = row['zenith'] intervalNo = row['intervalNo'] corrChunk = imageInterval[int(intervalNo)] # define a variable for the Google Extensions namespace URL string gxns = '{' + nsmap['gx'] + '}' #fly to the subChunk with the given subChunk parameters tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.flyToMode("bounce"), KML.LookAt( KML.longitude(longitude),#change chunk[] to subChunk from csv KML.latitude(latitude),#change chunk[] to subChunk from csv KML.altitude(camHeight),#change chunk[] to subChunk from csv KML.heading(azimuth),#change chunk[] to subChunk from csv KML.tilt(zenith),#change chunk[] to subChunk from csv KML.range(corrChunk['range0']),#change all chunk[] to subChunk from csv KML.altitudeMode(corrChunk['altitudeMode']), GX.horizFov(horizFov) ) ) ) tour_doc.Document[gxns+"Tour"].Playlist.append(GX.Wait(GX.duration(corrChunk['lookAtDuration'])))
def kml_addPathPoint(self, pos, dt): #pos[0] : latitude #pos[1] : longitude #pos[2] : altitude #pos[3] : roll #pos[4] : pitch #pos[5] : yaw if (pos == None): return #rospy.logerr(pos) self.tour_doc.Document[self.gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(dt), GX.flyToMode("smooth"), #KML.Camera( KML.LookAt( KML.latitude(pos[0]), KML.longitude(pos[1]), KML.altitude(pos[2]), KML.heading(pos[5]), #KML.tilt(pos[4] + 90.0), #KML.roll(pos[3]), KML.tilt(pos[4] + 75.0), KML.range(20.0), KML.altitudeMode("absolute"), ), ), ) auxStr = ' {lon},{lat},{alt}\n'.format(lon=pos[1], lat=pos[0], alt=pos[2]) #rospy.logerr(auxStr) self.execCoordListStr = self.execCoordListStr + auxStr
def build_test_kml(): """build a simple KML file with a simple LineString, for testing purposes""" from pykml.factory import KML_ElementMaker as KML from pykml.factory import GX_ElementMaker as GX from lxml import etree from django.http import HttpResponse kml = KML.kml( KML.Placemark( KML.name("build_test_kml output"), KML.LookAt( KML.longitude(146.806), KML.latitude(12.219), KML.heading(-60), KML.tilt(70), KML.range(6300), GX.altitudeMode("relativeToSeaFloor"), ), KML.LineString( KML.extrude(1), GX.altitudeMode("relativeToSeaFloor"), KML.coordinates( "146.825,12.233,400 " "146.820,12.222,400 " "146.812,12.212,400 " "146.796,12.209,400 " "146.788,12.205,400" ), ), ) ) kml_str = etree.tostring(kml) return HttpResponse(kml_str, content_type="application/vnd.google-earth.kml")
def test_basic_kml_document(self): """Tests the creation of a basic KML with Google Extensions .""" doc = KML.kml( GX.Tour( GX.Playlist( GX.SoundCue( KML.href('http://dev.keyhole.com/codesite/cntowerfacts.mp3') ), GX.Wait( GX.duration(10) ), GX.FlyTo( GX.duration(5), GX.flyToMode('bounce'), KML.LookAt( KML.longitude(-79.387), KML.latitude(43.643), KML.altitude(0), KML.heading(-172.3), KML.tilt(10), KML.range(1200), KML.altitudeMode('relativeToGround'), ) ) ) ) ) self.assertTrue(Schema('kml22gx.xsd').validate(doc)) data = etree.tostring(doc, encoding='ascii') expected = \ b'<kml xmlns:gx="http://www.google.com/kml/ext/2.2" ' \ b'xmlns:atom="http://www.w3.org/2005/Atom" ' \ b'xmlns="http://www.opengis.net/kml/2.2">' \ b'<gx:Tour>' \ b'<gx:Playlist>' \ b'<gx:SoundCue>' \ b'<href>http://dev.keyhole.com/codesite/cntowerfacts.mp3</href>' \ b'</gx:SoundCue>' \ b'<gx:Wait>' \ b'<gx:duration>10</gx:duration>' \ b'</gx:Wait>' \ b'<gx:FlyTo>' \ b'<gx:duration>5</gx:duration>' \ b'<gx:flyToMode>bounce</gx:flyToMode>' \ b'<LookAt>' \ b'<longitude>-79.387</longitude>' \ b'<latitude>43.643</latitude>' \ b'<altitude>0</altitude>' \ b'<heading>-172.3</heading>' \ b'<tilt>10</tilt>' \ b'<range>1200</range>' \ b'<altitudeMode>relativeToGround</altitudeMode>' \ b'</LookAt>' \ b'</gx:FlyTo>' \ b'</gx:Playlist>' \ b'</gx:Tour>' \ b'</kml>' self.assertXmlEquivalentOutputs(data, expected)
def get_kml_doc(llhs): """Generates a KML document from a Pandas table of single point solutions. Requires columns lat, lon, and height. """ from pykml.parser import Schema from pykml.factory import KML_ElementMaker as KML from pykml.factory import GX_ElementMaker as GX center = llhs[['lat', 'lon', 'height']].mean() elts = lambda e: '%s,%s,%d' % (e['lon'], e['lat'], e['height']) coords = ' '.join(llhs.apply(elts, axis=1).values) xml_coords = KML.coordinates(coords) doc = KML.kml( KML.Placemark( KML.name("gx:altitudeMode Example"), KML.LookAt( KML.longitude(center.lon), KML.latitude(center.lat), KML.heading(center.height), KML.tilt(70), KML.range(6300), GX.altitudeMode("relativeToSeaFloor"),), KML.LineString( KML.extrude(1), GX.altitudeMode("relativeToSeaFloor"), xml_coords ) ) ) return doc
def get_track(self, model_url=None): track = GX.Track(id=self.track_id) track.append(GX.altitudeMode('absolute')) while self.has_next_packet(): self.get_next_packet().append_telemetry_to(track) #if model_url is not None: # track.append(KML.Model(KML.Link(KML.href(model_url)), KML.Orientation(KML.heading(180)))) return track
def generate_update(self, change=None, create=None, delete=None): placemark = GX.Placemark(targetId=self.pm_id) track = GX.Track(targetId=self.track_id) while self.has_next_packet(): placemark.append(KML.description(self.get_description())) self.get_next_packet().append_telemetry_to(track) if placemark.countchildren() > 0: change.append(placemark) if track.countchildren() > 0: create.append(track)
def init_kml(KMLname): # start with a base KML tour and playlist tour_doc = KML.kml( KML.Document( GX.Tour( KML.name(KMLname), GX.Playlist(), ), ) ) return tour_doc
def build_xml(self): track = GX.Track() for position in self.track.positions: track.append( KML.when( "%s" % (position.timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'), ))) for position in self.track.positions: track.append( GX.coord("%f %f %d" % (float(position.lon) / 10000000, float(position.lat) / 10000000, position.alt))) return track
def task_to_kml_with_pykml(df_task, outdir, filename_base, disp): from lxml import etree from pykml.parser import Schema from pykml.factory import KML_ElementMaker as KML from pykml.factory import GX_ElementMaker as GX s_coords = task_to_string(df_task) (lat, lon) = calculate_center(df_task) #def turn_point_to_placemark(tp): # placemark = KML.Placemark( # KML.name(tp['Name']), # KML.description(tp['Name']), # KML.Point( # KML.coordinates(tp['Lon'], tp['Lat'], tp['Altitude']) # ), # ) # return(placemark) #placemarks = [turn_point_to_placemark(tp) for i, tp in df_task.iterrows()] doc = KML.kml( KML.Placemark( KML.name("Condor task '%s'" % filename_base), KML.LookAt( KML.longitude(lon), KML.latitude(lat), KML.heading(0), KML.tilt(60), KML.range(80000), GX.altitudeMode("relativeToSeaFloor"), #GX.altitudeMode("absolute"), ), KML.LineString( KML.extrude(1), GX.altitudeMode("relativeToSeaFloor"), #GX.altitudeMode("absolute"), KML.coordinates(s_coords), ), ), #*placemarks ) if disp: print(etree.tostring(doc, pretty_print=True)) # output a KML file (named based on the Python script) filename_out = os.path.join(outdir, filename_base + '.kml') print("Output '%s'" % filename_out) outfile = file(filename_out, 'w') outfile.write(etree.tostring(doc, pretty_print=True)) assert Schema('kml22gx.xsd').validate(doc)
def task_to_kml_with_pykml(df_task, outdir, filename_base, disp): from lxml import etree from pykml.parser import Schema from pykml.factory import KML_ElementMaker as KML from pykml.factory import GX_ElementMaker as GX s_coords = task_to_string(df_task) (lat, lon) = calculate_center(df_task) #def turn_point_to_placemark(tp): # placemark = KML.Placemark( # KML.name(tp['Name']), # KML.description(tp['Name']), # KML.Point( # KML.coordinates(tp['Lon'], tp['Lat'], tp['Altitude']) # ), # ) # return(placemark) #placemarks = [turn_point_to_placemark(tp) for i, tp in df_task.iterrows()] doc = KML.kml( KML.Placemark( KML.name("Condor task '%s'" % filename_base), KML.LookAt( KML.longitude(lon), KML.latitude(lat), KML.heading(0), KML.tilt(60), KML.range(80000), GX.altitudeMode("relativeToSeaFloor"), #GX.altitudeMode("absolute"), ), KML.LineString( KML.extrude(1), GX.altitudeMode("relativeToSeaFloor"), #GX.altitudeMode("absolute"), KML.coordinates(s_coords), ), ), #*placemarks ) if disp: print(etree.tostring(doc, pretty_print=True)) # output a KML file (named based on the Python script) filename_out = os.path.join(outdir, filename_base + '.kml') print("Output '%s'" % filename_out) outfile = file(filename_out,'w') outfile.write(etree.tostring(doc, pretty_print=True)) assert Schema('kml22gx.xsd').validate(doc)
def test_basic_kml_document(self): """Tests the creation of a basic KML with Google Extensions .""" doc = KML.kml( GX.Tour( GX.Playlist( GX.SoundCue( KML.href("http://dev.keyhole.com/codesite/cntowerfacts.mp3") ), GX.Wait( GX.duration(10) ), GX.FlyTo( GX.duration(5), GX.flyToMode("bounce"), KML.LookAt( KML.longitude(-79.387), KML.latitude(43.643), KML.altitude(0), KML.heading(-172.3), KML.tilt(10), KML.range(1200), KML.altitudeMode("relativeToGround"), ) ) ) ) ) self.assertTrue(Schema("kml22gx.xsd").validate(doc)) self.assertEqual( etree.tostring(doc).decode(), '<kml ' 'xmlns:atom="http://www.w3.org/2005/Atom" ' 'xmlns:gx="http://www.google.com/kml/ext/2.2" ' 'xmlns="http://www.opengis.net/kml/2.2">' '<gx:Tour>' '<gx:Playlist>' '<gx:SoundCue>' '<href>http://dev.keyhole.com/codesite/cntowerfacts.mp3</href>' '</gx:SoundCue>' '<gx:Wait>' '<gx:duration>10</gx:duration>' '</gx:Wait>' '<gx:FlyTo>' '<gx:duration>5</gx:duration>' '<gx:flyToMode>bounce</gx:flyToMode>' '<LookAt>' '<longitude>-79.387</longitude>' '<latitude>43.643</latitude>' '<altitude>0</altitude>' '<heading>-172.3</heading>' '<tilt>10</tilt>' '<range>1200</range>' '<altitudeMode>relativeToGround</altitudeMode>' '</LookAt>' '</gx:FlyTo>' '</gx:Playlist>' '</gx:Tour>' '</kml>' )
def makeplacemark(self): if self.__pointcount == 0: # We have no points since last placemark. Don't do anything. return if not self.__isstride: self.__coordstr += ' {},{},0 {},{},0'.format( self.__prevplacemarklng, self.__prevplacemarklat, self.__currlng, self.__currlat) placemark = KML.Placemark() geometry = KML.MultiGeometry( KML.LineString(KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.coordinates(self.__coordstr))) if self.__styletag is not None: placemark.append(KML.styleUrl('#' + str(self.__styletag))) placemark.append(geometry) if self.__startime is not None and self.__endtime is not None: placemark.append(_maketimespan(self.__startime, self.__endtime)) self.__kmlcontainer.append(placemark) self.__coordstr = '' self.__pointcount = 0 self.__prevplacemarklat = self.__currlat self.__prevplacemarklng = self.__currlng
def gen_kml(self): """ Generate a KML file with keypoints on the locations of the pictures, including height :return: """ style_dot = "sn_shaded_dot" style_path = "red_path" doc = KML.kml( KML.Document( KML.Name("GPS of the images"), KML.Style( KML.IconStyle( KML.scale(0.4), KML.Icon( KML.href( "http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png" )), ), id=style_dot, ), KML.Style(KML.LineStyle( KML.color('7f0000ff'), KML.width(6), GX.labelVisibility('1'), ), id=style_path))) # create points for i, gps in enumerate(self.tagged_gps): ii = i + 1 doc.Document.append( KML.Placemark( KML.styleUrl('#{0}'.format(style_dot)), KML.Point( KML.extrude(True), KML.altitudeMode('absolute'), KML.coordinates("{},{},{}".format( gps.lon, gps.lat, gps.alt))), KML.name(str(ii)) if ii % 5 == 0 or ii == 1 else KML.name())) # create the path doc.Document.append( KML.Placemark( KML.styleUrl('#{0}'.format(style_path)), KML.LineString( KML.altitudeMode('absolute'), KML.coordinates(' '.join([ "{},{},{}".format(gps.lon, gps.lat, gps.alt) for gps in self.tagged_gps ]))))) s = etree.tostring(doc) file_path = self.output + 'GoogleEarth_points.kml' f = open(file_path, 'w') f.write(s) f.close() print '[INFO] KML file generated on:', file_path
def writecoord(self): fea_list = self.loadjson(self.path)['features'] num = 1 for i in fea_list: coorlist = i['geometry'][ 'coordinates'] #[[8.4882786, 49.9307422], [8.4879952, 49.930298], [8.4878599, 49.9300566]] coord_str = '' for cood in coorlist: if isinstance(cood, list): coord_str += str(cood[0]) + ',' + str(cood[1]) + ',0 ' else: pass lookat = KML.Placemark( KML.name(num), KML.LookAt(KML.longitude(cood[0]), KML.latitude(cood[1]), KML.heading('-60'), KML.tilt('8.3'), KML.range('500')), KML.styleUrl('coolor1'), KML.Point( GX.drawOrder('1'), KML.coordinates(str(cood[0]) + ',' + str(cood[1]) + ',0 '), ), ) place = KML.Placemark( KML.name(num), KML.styleUrl('#type1'), KML.visibility('1'), KML.description(''), KML.LineString(KML.extrude('1'), KML.coordinates(coord_str))) self.fld.append(place), self.fld.append(lookat) num += 1 with open('./new.kml', 'w') as f: f.write(etree.tostring(self.fld, pretty_print=True))
def create_flyto_camera(location): flyto = GX.FlyTo( GX.duration(0.5), GX.flyToMode('smooth'), ) flyto.append( KML.Camera( KML.longitude(location['loc'].longitude), KML.latitude(location['loc'].latitude), KML.altitude(location['loc'].altitude), KML.heading(location['loc'].heading), KML.tilt(location['loc'].tilt), KML.roll(location['loc'].roll), KML.altitudeMode('relativeToGround'), )) return flyto
def constructKML(urls, course_name): """ Create KML files given the urls and the course names. """ doc = GX.kml() for url in urls: # print url #see if it prints urls name = url.split('/')[-1] point = points_dict.get(url) if point: langt, longt = point.strip('POINT()').split(' ') pm = GX.Placemark(GX.name(name), GX.Point(GX.coordinates(langt + ',' + longt))) doc.append(pm) xml = lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True) with open(OUTPUT_FOLDER + course_name + '.kml', 'w') as f: f.write(xml)
def create_flyto_camera(location): flyto = GX.FlyTo( GX.duration(0.5), GX.flyToMode('smooth'), ) flyto.append( KML.Camera( KML.longitude(location['loc'].longitude), KML.latitude(location['loc'].latitude), KML.altitude(location['loc'].altitude), KML.heading(location['loc'].heading), KML.tilt(location['loc'].tilt), KML.roll(location['loc'].roll), KML.altitudeMode('relativeToGround'), ) ) return flyto
def find_to_stand_over_the_placemark(self, duration, longitude, latitude, kml_doc): # rota fins estar a sobre de la ciutat i apropar-se kml_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(duration), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(longitude), KML.latitude(latitude), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(self.range), KML.altitudeMode("relativeToGround"), ) ), ) return kml_doc
def get_away_from_placemark(self, data, kml_doc): # fly to a space viewpoint. Allunyar-se de la ciutat per buscar el seguent punt kml_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(8.0), GX.flyToMode("bounce"), KML.LookAt( KML.longitude(float(data.longitude)), KML.latitude(float(data.latitude)), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(self.range), KML.altitudeMode("relativeToGround"), ) ), ) return kml_doc
def SetView(self, lat=0.0, lon=0.0, heading=0.0, tilt=0.0, view_range=0.0): look_at_ = KML.LookAt( KML.longitude(lon), KML.latitude(lat), KML.heading(heading), KML.tilt(tilt), KML.range(view_range), GX.altitudeMode('absolute'), ) self.KmlDoc.Document.append(look_at_)
def constructKML(urls, course_name): """ Create KML files given the urls and the course names. """ doc = GX.kml() for url in urls: # print url #see if it prints urls name = url.split('/')[-1] point = points_dict.get(url) if point: langt, longt = point.strip('POINT()').split(' ') pm = GX.Placemark( GX.name(name), GX.Point( GX.coordinates(langt + ',' + longt)) ) doc.append(pm) xml = lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True) with open(OUTPUT_FOLDER+course_name+'.kml', 'w') as f: f.write(xml)
def addsegment(kmlcontainer, styletag, lata, lnga, latb, lngb, name='segment'): coordstr = ' {},{},0 {},{},0'.format(lnga, lata, lngb, latb) placemark = KML.Placemark( KML.styleUrl('#' + str(styletag)), KML.name(name), KML.MultiGeometry( KML.LineString(KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.coordinates(coordstr)))) kmlcontainer.append(placemark)
def fly_to_the_placemark(self, longitude, latitude, params, mode, kml_doc): # fly to the data kml_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(params[0]), GX.flyToMode(mode), KML.LookAt( KML.longitude(longitude), KML.latitude(latitude), KML.altitude(params[1]), KML.heading(params[2]), KML.tilt(params[3]), KML.name(params[4].upper()), KML.range(params[5]), KML.altitudeMode("relativeToGround"), ) ), ) return kml_doc
def generateKML_Line_Track_Experience (self,data_points): linetrack_experience_kml_doc = self.KML_file_header(["",""],"Line Track Experience") longitude = str(data_points[0]).split(",")[0].split("['")[1] latitude = str(data_points[0]).split(",")[1].split("']")[0] linetrack_experience_kml_doc = self.find_to_stand_over_the_placemark(2.0,longitude,latitude,linetrack_experience_kml_doc) i = 0 while i < len(data_points)-1: data_list = [] data_list.append(str(data_points[i]).split(",")[0].split("['")[1]) data_list.append(str(data_points[i]).split(",")[1].split("']")[0]) data_list.append(str(data_points[i+1]).split(",")[0].split("['")[1]) data_list.append(str(data_points[i+1]).split(",")[1].split("']")[0]) iid = str((i+1)) linetrack_experience_kml_doc = self.add_placemark_simple_line(data_list,iid,linetrack_experience_kml_doc) i = i+1 i = 0 while i < len(data_points)-1: linetrack_experience_kml_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(0.06))) linetrack_experience_kml_doc.Document[gxns + "Tour"].Playlist.append( GX.AnimatedUpdate( KML.Update( KML.Change( KML.Placemark( KML.visibility(1), targetId=str((i+1)), ) ) ) ) ) i = i+1 return self.save_kml_file(self.kml_name, linetrack_experience_kml_doc)
def build_xml(self): track = GX.Track( ) for position in self.track.positions: track.append(KML.when("%s" % ( position.timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'),) )) for position in self.track.positions: track.append(GX.coord("%f %f %d" % ( float(position.lon)/10000000, float(position.lat)/10000000, position.alt)) ) return track
def addboundingbox(kmlcontainer, styletag, nelat, nelng, swlat, swlng): coordstr = ' {},{},0'.format(nelng, nelat) coordstr += ' {},{},0'.format(nelng, swlat) coordstr += ' {},{},0'.format(swlng, swlat) coordstr += ' {},{},0'.format(swlng, nelat) coordstr += ' {},{},0'.format(nelng, nelat) placemark = KML.Placemark( KML.styleUrl('#' + str(styletag)), KML.Polygon( KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.outerBoundaryIs(KML.LinearRing(KML.coordinates(coordstr))))) kmlcontainer.append(placemark)
def compute_kml_point_description(coord, name): coords_str = " " + ",".join(str(num) for num in coord) + " " description = KML.Placemark( KML.name(name), KML.Point( # https://developers.google.com/kml/documentation/altitudemode # possible values: # from the surface of the Earth(relativeToGround) # above sea level(absolute) # from the bottom of major bodies of water (relativeToSeaFloor) GX.altitudeMode("absolute"), KML.coordinates(coords_str), ), ) return description
def make_kml(self, lon, lat): """ :return: write kml file from defined properties """ doc = KML.kml( etree.Comment(' required when using gx-prefixed elements '), GX.FlyTo( GX.flyToMode('bounce'), GX.duration('0.5') ), KML.Placemark( KML.name('gx:altitudeMode Example'), KML.Camera( KML.altitude(self.vh), KML.longitude(str(lon)), KML.latitude(str(lat)) ), ), ) string = etree.tostring(etree.ElementTree(doc),pretty_print=True) #writeToFile f = open(self.outfile, 'w') f.writelines(string) f.close()
def addpolygon(kmlcontainer, styletag, coordlist, name='polygon'): coordstr = '' first = None for coord in coordlist: if first is None: first = coord coordstr += ' {},{},0'.format(coord.lon, coord.lat) coordstr += ' {},{},0'.format(first.lon, first.lat) placemark = KML.Placemark( KML.name(name), KML.styleUrl('#' + str(styletag)), KML.Polygon( KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.outerBoundaryIs(KML.LinearRing(KML.coordinates(coordstr))))) kmlcontainer.append(placemark)
def compute_kml_line_3d_description(coord_list, name): coord_str_list = [" "] for coord in coord_list: coords_str = ",".join(str(num) for num in coord) + " " coord_str_list.append(coords_str) description = KML.Placemark( KML.name(name), KML.LineString( # https://developers.google.com/kml/documentation/altitudemode # possible values: # from the surface of the Earth(relativeToGround) # above sea level(absolute) # from the bottom of major bodies of water (relativeToSeaFloor) GX.altitudeMode("absolute"), KML.coordinates(*coord_str_list), ), ) return description
def append_linestring(timeDiff, dist, normalized, thisStyle, row): doc.append( KML.Placemark( KML.name("Point " + str(count/lineReduceNumBy)), KML.ExtendedData( KML.Data(KML.value(timeDiff), name="Time Length"), KML.Data(KML.value(dist), name="Distance Metres"), KML.Data(KML.value(dist/timeDiff.seconds), name="Average Speed m/s"), KML.Data(KML.value(normalized), name="Normalized Speed"), ), KML.styleUrl("#{}".format(thisStyle)), KML.LineString( KML.extrude('1'), GX.altitudeMode('relative'), KML.coordinates( previousPoint, "{},{},{}".format(row['LOCATION Longitude : '],row['LOCATION Latitude : '],0) ) ) ))
def addsegments(kmlcontainer, styletag, points, stride=50): pointiter = iter(points) try: initialpoint = next(pointiter) except StopIteration: raise ValueError('Number of points is 0') nsegmentsadded = 0 currlat = initialpoint[0] currlng = initialpoint[1] coordstr = '' for i, point in enumerate(pointiter): if (i + 1) % stride != 0: continue nextlat = point[0] nextlng = point[1] coordstr += ' {},{},0 {},{},0'.format(currlng, currlat, nextlng, nextlat) currlat = nextlat currlng = nextlng nsegmentsadded += 1 if nsegmentsadded == 0: coordstr += ' {},{},0 {},{},0'.format(initialpoint[1], initialpoint[0], currlng, currlat) placemark = KML.Placemark( KML.styleUrl('#' + str(styletag)), KML.MultiGeometry( KML.LineString(KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.coordinates(coordstr)))) kmlcontainer.append(placemark)
def show_placemark_balloon(self, duration, target, kml_doc): # show the placemark balloon kml_doc.Document[gxns + "Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(1.0), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( KML.visibility(1), GX.balloonVisibility(1), targetId=target.replace(' ', '_') ) ) ) ) ) kml_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(duration))) kml_doc.Document[gxns + "Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(0.5), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( GX.balloonVisibility(0), targetId=target.replace(' ', '_') ) ) ) ) ) return kml_doc
def output_data_to_file(road_data): stylename = 'blueLine' doc = KML.kml( KML.Document( KML.Name("yan an"), KML.Style(KML.LineStyle(KML.color('FFF00014'), KML.width('5.0')), id=stylename))) for road in road_data: pm = KML.Placemark( KML.name(road.road_id), KML.styleUrl('#{0}'.format(stylename)), KML.LineString( KML.extrude(0), GX.altitudeMode("absolute"), KML.coordinates(' '.join([ turn_3857_project_to_4326(p) for p in road.points_with_z_value_list ])))) doc.Document.append(pm) f = open("model/test_yan_an4.kml", 'w') f.write(str(etree.tostring(doc))) f.close()
def addcircle(kmlcontainer, styletag, node, radius, name='circle', nsegments=50): if nsegments < 3: raise ValueError('Circle must be made up of 3 or more segments.') arclength = 360.0 / float(nsegments) currdegree = 0.0 currnode = None coordstr = '' firstnode = None for i in range(nsegments): nextnode = node.destinationnode(currdegree, radius) if currnode is not None: coordstr += ' {},{},0 {},{},0'.format(currnode.lon, currnode.lat, nextnode.lon, nextnode.lat) else: firstnode = nextnode currnode = nextnode currdegree += arclength if firstnode is not None: coordstr += ' {},{},0 {},{},0'.format(currnode.lon, currnode.lat, firstnode.lon, firstnode.lat) placemark = KML.Placemark( KML.styleUrl('#' + str(styletag)), KML.name(name), KML.Polygon( KML.tessellate('1'), GX.altitudeMode('clampToGround'), KML.outerBoundaryIs(KML.LinearRing(KML.coordinates(coordstr))))) kmlcontainer.append(placemark)
GX.Playlist(), ) ) with open("colorado_river_linestring.kml", 'rb') as f: linestring_doc = parse(f) # get the coordinate string of the first KML coordinate element coord_str = str( linestring_doc.getroot().find(".//{http://www.opengis.net/kml/2.2}coordinates") ).strip() for vertex in coord_str.split(' '): (lon, lat, alt) = vertex.split(',') flyto = GX.FlyTo( GX.duration(2), GX.flyToMode("smooth"), KML.Camera( KML.longitude(lon), KML.latitude(lat), KML.altitude(0), KML.heading(-129.7), KML.tilt(90.0), KML.altitudeMode("relativeToGround"), ) ) tour_doc[gxns + "Tour"].Playlist.append(flyto) assert Schema('kml22gx.xsd').validate(tour_doc) print(etree.tostring(tour_doc, pretty_print=True))
from lxml import etree from pykml.parser import Schema from pykml.factory import KML_ElementMaker as KML from pykml.factory import GX_ElementMaker as GX doc = KML.kml( KML.Placemark( KML.name("gx:altitudeMode Example"), KML.LookAt( KML.longitude(146.806), KML.latitude(12.219), KML.heading(-60), KML.tilt(70), KML.range(6300), GX.altitudeMode("relativeToSeaFloor"), ), KML.LineString( KML.extrude(1), GX.altitudeMode("relativeToSeaFloor"), KML.coordinates( "146.825,12.233,400 " "146.820,12.222,400 " "146.812,12.212,400 " "146.796,12.209,400 " "146.788,12.205,400" ) ) ) )
def gen_klm(self): """ Generate a KML file with keypoints on the locations of the pictures, including height :return: """ style_dot = "sn_shaded_dot" style_path = "red_path" doc = KML.kml( KML.Document( KML.Name("GPS of the images"), KML.Style( KML.IconStyle( KML.scale(0.4), KML.Icon( KML.href("http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png") ), ), id=style_dot, ), KML.Style( KML.LineStyle( KML.color('7f0000ff'), KML.width(6), GX.labelVisibility('1'), ), id=style_path ) ) ) # create points for i, gps in enumerate(self.tagged_gps): ii = i + 1 doc.Document.append( KML.Placemark( KML.styleUrl('#{0}'.format(style_dot)), KML.Point( KML.extrude(True), KML.altitudeMode('relativeToGround'), KML.coordinates("{},{},{}".format(gps.lon, gps.lat, gps.alt)) ), KML.name(str(ii)) if ii % 5 == 0 or ii == 1 else KML.name() ) ) # create the path doc.Document.append( KML.Placemark( KML.styleUrl('#{0}'.format(style_path)), KML.LineString( KML.altitudeMode('relativeToGround'), KML.coordinates( ' '.join(["{},{},{}".format(gps.lon, gps.lat, gps.alt) for gps in self.tagged_gps]) ) ) ) ) s = etree.tostring(doc) file_path = self.output + 'GoogleEarth_points.kml' f = open(file_path,'w') f.write(s) f.close() print '[INFO] KML file generated on:', file_path
def __tour__(self): # Define a variable for the Google Extensions namespace URL string gxns = '{' + nsmap['gx'] + '}' tour = GX.Tour(KML.name('Play me!'), GX.Playlist()) tour.Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode('smooth'), KML.LookAt( KML.longitude(-45), KML.latitude(-43), KML.altitude(0), KML.heading(355), KML.tilt(55), KML.range(6000000.0), KML.altitudeMode('absolute')))) tour.Playlist.append( GX.FlyTo( GX.duration(10), GX.flyToMode('smooth'), KML.LookAt( KML.longitude(-80), KML.latitude(63), KML.altitude(0), KML.heading(345), KML.tilt(45), KML.range(10000000.0), KML.altitudeMode('absolute')))) tour.Playlist.append( GX.FlyTo( GX.duration(10), GX.flyToMode('smooth'), KML.LookAt( KML.longitude(-131), KML.latitude(63), KML.altitude(0), KML.heading(345), KML.tilt(35), KML.range(20000000.0), KML.altitudeMode('absolute')))) tour.Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode('smooth'), KML.LookAt( KML.longitude(53), KML.latitude(25), KML.altitude(0), KML.heading(270), KML.tilt(35), KML.range(20000000.0), KML.altitudeMode('absolute')))) tour.Playlist.append( GX.FlyTo( GX.duration(10), GX.flyToMode('smooth'), KML.LookAt( KML.longitude(140), KML.latitude(-4), KML.altitude(0), KML.heading(0), KML.tilt(55), KML.range(10000000.0), KML.altitudeMode('absolute')))) return tour
def read_track_from_gpx(self, filepath, filebase, trackfolder, colourIndex): """ Read a single GPX file and extract the track(s), converting them to a list of KML tracks. Append or replace each track in the trackfolder. This fills the trackfolder in makekml. Arguments: filepath: the full path to the GPX file filebase: the basename of the GPX file, used to name the KML tracks trackfolder: a KML.Folder to hold track Placemarks colourIndex: the next colourIndex to use when creating a linestyle On successful exit, trackfolder and colourIndex will have been updated. """ args = self.config['arguments'] gpxtree = etree.parse(filepath).getroot() namespace = gpxtree.nsmap[None] if self.verbosity > 1: print('namespace for ' + filepath + ': ' + namespace, file=sys.stderr) print('{%s}trk' % namespace, file=sys.stderr) print(namespace + 'trk', file=sys.stderr) for gpxtrack in gpxtree.getiterator('{%s}trk' % namespace): print('got here', file=sys.stderr) # Extract the track name from the GPX track try: trackname = gpxtrack.find('{%s}name' % namespace).text except: print('track does not have name in ' + filepath, file=sys.stderr) trackname = filebase print('trackname = ' + trackname, file=sys.stderr) # does a Placemark already exist with this name? placemark = None for pm in trackfolder.findall('GX.Placemark'): if pm.find('KML.name').text == trackname: placemark = pm break if 'replace' in args and args['replace']: trackfolder.drop(placemark) placemark = None if not placemark: # Create a new Placemark to hold the KML track(s) colourID = '#colour' + str(self.colourIndex) self.colourIndex = (self.colourIndex + 1) % self.colourSetLen placemark = KML.Placemark( KML.visibility('1'), KML.name(trackname), KML.description(trackname + ' from ' + filebase), KML.styleUrl(colourID) ) trackfolder.append(placemark) tracklist = [] for gpxtrkseg in gpxtrack.getiterator('{%s}trkseg' % namespace): # A GPX trkseg translates into aGX.track kmltrack = GX.Track( KML.altitudeMode('clampToGround') ) whenlist = [] coordlist = [] for gpxtrkpoint in gpxtrkseg: lat = gpxtrkpoint.attrib['lat'] lon = gpxtrkpoint.attrib['lon'] alt = gpxtrkpoint.find('{%s}ele'% namespace).text time = gpxtrkpoint.find('{%s}time'% namespace).text whenlist.append(GX.when(time)) coordlist.append(GX.coord('{0} {1} {2}'.format(lon, lat, alt))) for w in whenlist: kmltrack.append(w) for c in coordlist: kmltrack.append(c) tracklist.append(kmltrack) if tracklist: if len(tracklist) > 1: multitrack = GX.MultiTrack() for t in tracklist: multitrack.append(t) placemark.append(multitrack) else: placemark.append(tracklist[0]) else: print('no tracks found in ' + filepath, file=sys.stderr)
), id="pushpin" ), KML.Placemark( KML.name("Pin on a mountaintop"), KML.styleUrl("#pushpin"), KML.Point( KML.coordinates(170.1435558771009,-43.60505741890396,0) ), id="mountainpin1" ), GX.Tour( KML.name("Play me!"), GX.Playlist( GX.FlyTo( GX.duration(3), GX.flyToMode("bounce"), KML.Camera( KML.longitude(170.157), KML.latitude(-43.671), KML.altitude(9700), KML.heading(-6.333), KML.tilt(33.5), ) ), GX.AnimatedUpdate( GX.duration(5), KML.Update( KML.targetHref(), KML.Change( KML.IconStyle(
route = json.loads( urllib2.urlopen(URL).read() ) pList = '' for point in route: pList = pList + str(point['lon']) + ',' + str(point['lat']) +',1,' pm = KML.Placemark( KML.name('Curiosity traversal'), KML.LookAt( KML.longitude(route[0]['lon']), KML.latitude(route[0]['lat']), KML.heading('0'), KML.tilt('40'), KML.range('2000'), GX.altitudeMode('relativeToSeaFloor'), ), KML.LineStyle( KML.color('#00FFFF'), KML.width(10) ), KML.altitudeMode('clampToGround'), KML.LineString(KML.extrude('1'), GX.altitudeMode('relativeToSeaFloor'), KML.coordinates(pList)) ) folder = KML.Folder() folder.append(pm) # create a document element with a single label style kmlobj = KML.kml( KML.Document(
GX.Tour( KML.name("Play me!"), GX.Playlist(), ), KML.Folder( KML.name('Features'), id='features', ), ) ) for feature in feature_list: # import ipdb; ipdb.set_trace() # fly to a space viewpoint tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(feature['lon']), KML.latitude(feature['lat']), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(10000000.0), KML.altitudeMode("relativeToGround"), ) ), ) # fly to the feature tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo(
def main(): # ############################################################################### usage = "usage: %prog [options] <gpxfile>\n\n" usage += "where:\n" usage += " <gpxfile>\tgpx formatted file" parser = optparse.OptionParser(usage=usage) parser.add_option("-p", "--points", dest="points", action="store_true", help="specify if points output is desired", default=False) parser.add_option("-f", "--flyover", dest="flyover", action="store_true", help="specify if flyover output is desired", default=False) parser.add_option("-c", "--color", dest="color", help="track color if not flyover", default='641400FF') parser.add_option("-o", "--output", dest="output", help="output file", default=None) (options, args) = parser.parse_args() # see http://www.zonums.com/gmaps/kml_color/ colors = {'pink':'64781EF0', 'blue':'64F01E14'} gpxfile = args.pop(0) if options.output == None: outfile = os.path.basename(gpxfile) + '.kml' else: outfile = options.output # get input _GPX = open(gpxfile,'r') gpx = gpxpy.parse(_GPX) # create a KML file skeleton stylename = "sn_shaded_dot" color = colors[options.color] sty = KML.Style( KML.IconStyle( KML.scale(1.2), KML.Icon( KML.href("http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png") ), KML.color(colors[options.color]), ), id=stylename, ) iconstylename = '#sn_shaded_dot' doc = KML.Document( KML.Name('generated from {0}'.format(gpxfile)), KML.open(1), ) doc.append(sty) ''' <TimeStamp> <when>1997-07-16T07:30:15Z</when> </TimeStamp> ''' # loop through gpx tracks, creating kml placemarks times = [] coords = [] dists = [] points = [] lastpoint = None for track in gpx.tracks: for segment in track.segments: for point in segment.points: if not lastpoint: lastpoint = point plon = point.longitude plat = point.latitude pelev = point.elevation points.append(point) thisdist = gpxpy.geo.distance(lastpoint.latitude, lastpoint.longitude, lastpoint.elevation, plat, plon, pelev) lastpoint = point dists.append(thisdist) ptime = t.dt2asc(point.time) times.append(ptime) coords.append('{lon},{lat},{alt}'.format(lon = plon,lat = plat,alt = 0)) if options.flyover: plm = KML.Placemark() doc.append(plm) track = GX.track() plm.append(track) for when in times: track.append(KML.when(when)) for coord in coords: track.append(KML.coordinates(coord)) ''' doc.append(KML.Placemark( KML.LookAt( KML.longitude(plon), KML.latitude(plat), KML.tilt(45), KML.heading(0), # make this behind the guy KML.altitudeMode("relativeToGround"), KML.range(50), ), KML.Point( KML.altitudeMode("relativeToGround"), , , ) )) ''' elif options.points: #for coord in coords: # ls.append(KML.coordinates(coord)) lasttime = t.asc2epoch(times[0]) totdist = 0 for i in range(len(times)): thistime = t.asc2epoch(times[i]) dur = thistime - lasttime lasttime = thistime totdist += dists[i] ex = KML.ExtendedData( KML.Data(KML.displayName('time'),KML.value(times[i])), KML.Data(KML.displayName('duration'),KML.value(dur)), KML.Data(KML.displayName('totdistance'),KML.value(int(round(totdist)))), ) plm = KML.Placemark( #KML.name(times[i]), KML.name(''), KML.styleUrl(iconstylename), ) plm.append(ex) plm.append(KML.Point( KML.altitudeMode('clampToGround'), KML.coordinates(coords[i]))) doc.append(plm) else: if options.color: doc.append( KML.Style( KML.LineStyle( KML.color(colors[options.color]), KML.width(5), ), id=options.color)) stylename = '#{0}'.format(options.color) ''' <LineString id="ID"> <!-- specific to LineString --> <gx:altitudeOffset>0</gx:altitudeOffset> <!-- double --> <extrude>0</extrude> <!-- boolean --> <tessellate>0</tessellate> <!-- boolean --> <altitudeMode>clampToGround</altitudeMode> <!-- kml:altitudeModeEnum: clampToGround, relativeToGround, or absolute --> <!-- or, substitute gx:altitudeMode: clampToSeaFloor, relativeToSeaFloor --> <gx:drawOrder>0</gx:drawOrder> <!-- integer --> <coordinates>...</coordinates> <!-- lon,lat[,alt] --> </LineString> ''' plm = KML.Placemark( KML.name('runtrack'), ) if options.color: plm.append(KML.styleUrl(stylename)) doc.append(plm) ls = KML.LineString( KML.altitudeMode('clampToGround'), # KML.extrude(1), # KML.tessellate(1), ) plm.append(ls) #for coord in coords: # ls.append(KML.coordinates(coord)) kcoords = '' for coord in coords: kcoords += coord + ' \n' ls.append(KML.coordinates(kcoords)) _GPX.close() kml = KML.kml(doc) docstr = etree.tostring(kml, pretty_print=True) OUT = open(outfile,'w') OUT.write(docstr) OUT.close()
def create_kml_tour(addresses, filename): ''' Creates a kml tour of the sites Modified from pykml example here https://pythonhosted.org/pykml/examples/tour_examples.html python Generate a KML document of a tour based on rotating around locations. ''' tilt = 20 distance = 20 # define a variable for the Google Extensions namespace URL string gxns = '{' + nsmap['gx'] + '}' # start with a base KML tour and playlist tour_doc = KML.kml( KML.Document( GX.Tour( KML.name("Play me!"), GX.Playlist(), ), KML.Folder( KML.name('Sites'), id='sites', ), ) ) for address in addresses: #import ipdb; ipdb.set_trace() # fly to a space viewpoint tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(address['longitude']), KML.latitude(address['latitude']), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(10000000.0), KML.altitudeMode("relativeToGround"), ) ), ) # fly to the address tilt = tilt + 10 distance = distance + 10 tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(0.25), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(address['longitude']), KML.latitude(address['latitude']), KML.altitude(0), KML.heading(0), ## KML.tilt(address['tilt']), ## KML.range(address['range']), KML.tilt(tilt), KML.range(distance), KML.altitudeMode("relativeToGround"), ) ), ) # add a placemark for the address tour_doc.Document.Folder.append( KML.Placemark( KML.name("?"), KML.description( "<h1>{name}</h1><br/>{desc}".format( name=address['Site'], desc=address['Bandwidth'], ) ), KML.Point( KML.extrude(1), KML.altitudeMode("relativeToGround"), KML.coordinates("{lon},{lat},{alt}".format( lon=address['longitude'], lat=address['latitude'], alt=50, ) ) ), id=address['Site'].replace(' ','_') ) ) # show the placemark balloon tour_doc.Document[gxns+"Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(2.0), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( KML.visibility(1), GX.balloonVisibility(1), targetId=address['Site'].replace(' ','_') ) ) ) ) ) tour_doc.Document[gxns+"Tour"].Playlist.append(GX.Wait(GX.duration(2.0))) tour_doc.Document[gxns+"Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(2.0), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( GX.balloonVisibility(0), targetId=address['Site'].replace(' ','_') ) ) ) ) ) # spin around the address for aspect in range(0,360,10): tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(0.25), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(address['longitude']), KML.latitude(address['latitude']), KML.altitude(0), KML.heading(aspect), KML.tilt(tilt), KML.range(distance), KML.altitudeMode("relativeToGround"), ) ) ) for angle in range(0,360,10): tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(0.25), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(address['longitude']), KML.latitude(address['latitude']), KML.altitude(0), KML.heading(angle), ## KML.tilt(address['tilt']), ## KML.range(address['range']), KML.tilt(tilt), KML.range(distance), KML.altitudeMode("relativeToGround"), ) ) ) tour_doc.Document[gxns+"Tour"].Playlist.append(GX.Wait(GX.duration(1.0))) # tour_doc.Document[gxns+"Tour"].Playlist.append( # GX.TourControl(GX.playMode("pause")) # ) # fly to a space viewpoint tour_doc.Document[gxns+"Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("bounce"), KML.LookAt( KML.longitude(address['longitude']), KML.latitude(address['latitude']), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(10000000.0), KML.altitudeMode("relativeToGround"), ) ), ) # check that the KML document is valid using the Google Extension XML Schema #assert(Schema("kml22gx.xsd").validate(tour_doc)) #always bombs # print etree.tostring(tour_doc, pretty_print=True) # output a KML file (named based on the Python script) outfile = kmlfile + '_tour.kml' with open(outfile,'w') as file: file.write(etree.tostring(tour_doc, pretty_print=True)) return
def append_telemetry_to(self, element): #if self.has_timestamp(): # element.append(KML.when(self.get_nice_timestamp())) if self.has_position(): if self.packet.position[2] != 110001: element.append(GX.coord(self.get_nice_position()))
def makeFile(self): # define a variable for the Google Extensions namespace URL string gxns = '{' + nsmap['gx'] + '}' stylename = "sn_shaded_dot" # start with a base KML tour and playlist tour_doc = KML.kml( KML.Document( GX.Tour( KML.name("Play me!"), GX.Playlist(), ), KML.Folder( KML.name('Features'), id='features', ), KML.Style( KML.IconStyle( KML.scale(1.2), KML.Icon( KML.href(self.icon) ), ), id=stylename, ) ) ) for data in self.data_set: # import ipdb; ipdb.set_trace() # fly to a space viewpoint tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(float(data['coordinates']['lng'])), KML.latitude(float(data['coordinates']['lat'])), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(10000000.0), KML.altitudeMode("relativeToGround"), ) ), ) # fly to the data tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("bounce"), KML.LookAt( KML.longitude(float(data['coordinates']['lng'])), KML.latitude(float(data['coordinates']['lat'])), KML.altitude(0), KML.heading(0), KML.tilt(data['data']), KML.name(data['data']), KML.range(self.range), KML.altitudeMode("relativeToGround"), ) ), ) # spin around the data for aspect in range(0, 360, 10): tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(0.25), GX.flyToMode("smooth"), KML.LookAt( KML.longitude(float(data['coordinates']['lng'])), KML.latitude(float(data['coordinates']['lat'])), KML.altitude(0), KML.heading(aspect), KML.tilt(data['data']), KML.name(data['data']), KML.range(self.range), KML.altitudeMode("relativeToGround"), ) ) ) tour_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(1.0))) # tour_doc.Document[gxns+"Tour"].Playlist.append( # GX.TourControl(GX.playMode("pause")) # ) # add a placemark for the data tour_doc.Document.Folder.append( KML.Placemark( KML.name(data['data']), KML.description( "<h1>" + data['data'] + "</h1>" ), KML.styleUrl('#{0}'.format(stylename)), KML.Point( KML.extrude(1), KML.altitudeMode("relativeToGround"), KML.coordinates("{lon},{lat},{alt}".format( lon=float(data['coordinates']['lng']), lat=float(data['coordinates']['lat']), alt=50, ) ) ), id=data['data'].replace(' ', '_') ) ) # show the placemark balloon tour_doc.Document[gxns + "Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(2.0), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( KML.visibility(1), GX.balloonVisibility(1), targetId=data['data'].replace(' ', '_') ) ) ) ) ) tour_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(2.0))) tour_doc.Document[gxns + "Tour"].Playlist.append( GX.AnimatedUpdate( GX.duration(2.0), KML.Update( KML.targetHref(), KML.Change( KML.Placemark( GX.balloonVisibility(0), targetId=data['data'].replace(' ', '_') ) ) ) ) ) # fly to a space viewpoint tour_doc.Document[gxns + "Tour"].Playlist.append( GX.FlyTo( GX.duration(5), GX.flyToMode("bounce"), KML.LookAt( KML.longitude(float(data['coordinates']['lng'])), KML.latitude(float(data['coordinates']['lat'])), KML.altitude(0), KML.heading(0), KML.tilt(0), KML.range(10000000.0), KML.altitudeMode("relativeToGround"), ) ), ) # check that the KML document is valid using the Google Extension XML Schema # assert(Schema("kml22gx.xsd").validate(tour_doc)) # print etree.tostring(tour_doc, pretty_print=True) # output a KML file (named based on the Python script) outfile = file("kmls_management/static/" + self.kml_name, 'w') outfile.write(etree.tostring(tour_doc, pretty_print=True))
z0 = loc0['altitude'] z1 = loc1['altitude'] deltat = (-vz - math.sqrt(vz**2 - 2 * g * (z0 - z1))) / g deltat = 30 # set manually, not sure what is wrong with the previous eqn #import ipdb; ipdb.set_trace() # calculate the horizontal and rotational velocities vy = (loc1['latitude'] - loc0['latitude']) / deltat vx = (loc1['longitude'] - loc0['longitude']) / deltat vh = (loc1['heading'] - loc0['heading']) / deltat vt = (loc1['tilt'] - loc0['tilt']) / deltat # create a tour object tour_doc = kml.kml(kml.Folder(gx.Tour( kml.name("Play me!"), gx.Playlist(), ))) tstep = 0.1 for t in drange(0, 15, tstep): pm = kml.Placemark( kml.name(str(t)), kml.Point( kml.altitudeMode("absolute"), kml.coordinates("{lon},{lat},{alt}".format( lon=loc0['longitude'] + vx * t, lat=loc0['latitude'] + vy * t, alt=loc0['altitude'] + vz * t + 0.5 * g * t**2, )), )) tour_doc.Folder.append(pm)
pm = kml.Placemark( kml.name(str(t)), kml.Point( kml.altitudeMode("absolute"), kml.coordinates("{lon},{lat},{alt}".format( lon=loc0['longitude'] + vx * t, lat=loc0['latitude'] + vy * t, alt=loc0['altitude'] + vz * t + 0.5 * g * t ** 2, )), ) ) tour_doc.Folder.append(pm) flyto = gx.FlyTo( gx.duration(tstep), gx.flyToMode("smooth"), kml.Camera( kml.longitude(loc0['longitude'] + vx * t), kml.latitude(loc0['latitude'] + vy * t), kml.altitude(loc0['altitude'] + vz * t + 0.5 * g * t ** 2), kml.heading(loc0['heading'] + vh * t), kml.tilt(loc0['tilt'] + vt * t), kml.altitudeMode("absolute"), ) ) tour_doc.Folder[GX_ns + "Tour"].Playlist.append(flyto) assert Schema('kml22gx.xsd').validate(tour_doc) print(etree.tostring(tour_doc, pretty_print=True,
def appendTrackPlacemarks(self, doc, directory, et): """ Append to the KML document doc a folder containing one or more tracks for the JPEG files in directory, and a folder containing a set of placemarks for each file. A separate track will be generated for each day, assigning colours in a cycle from the colourSet. Arguments: doc: the KML document to which the folder will be appended directory: the abspath to the directory containing the files et: an ExifTool object """ # Extract time, orientation and GPS metadata from EXIF items = ['EXIF:DateTimeOriginal', 'EXIF:GPSStatus', 'EXIF:GPSMeasureMode', 'EXIF:GPSLongitude', 'EXIF:GPSLongitudeRef', 'EXIF:GPSLatitude', 'EXIF:GPSLatitudeRef', 'EXIF:GPSAltitude'] basedir = os.path.basename(directory) # Gather JPEG metadata into places places = {} for f in os.listdir(directory): if self.verbosity > 0: print('search for JPEG files in ' + directory, file=sys.stderr) filebase, fileext = os.path.splitext(f) if fileext in ('.jpg', '.JPG', '.jpeg', '.JPEG'): filepath = os.path.join(directory, f) in_kml = '' tags = et.get_tags(items, filepath) if self.verbosity > 1: for k in tags: print(k, ' = ', tags[k], file=sys.stderr) if 'EXIF:GPSLongitude' in tags: # GPS metadata id available lat = lon = None datestr = timestr = '' alt = 0 if "EXIF:GPSLatitude" in tags: lat = tags['EXIF:GPSLatitude'] if 'EXIF:GPSLatitudeRef' in tags and \ tags['EXIF:GPSLatitudeRef'] == 'S': lat = -lat if "EXIF:GPSLongitude" in tags: lon = tags['EXIF:GPSLongitude'] if 'EXIF:GPSLongitudeRef' in tags and \ tags['EXIF:GPSLongitudeRef'] == 'W': lon = -lon if "EXIF:DateTimeOriginal" in tags: m = re.match(r'\s*(\d+:\d+:\d+)\s+' r'(\d+:\d+:[\d.]+)\s*', tags['EXIF:DateTimeOriginal']) datestr = re.sub(r':', '-', m.group(1)) timestr = m.group(2) if "EXIF:GPSAltitude" in tags: alt = tags['EXIF:GPSAltitude'] if self.verbosity > 1: print(datestr, timestr, lat, lon, alt, '\n', file=sys.stderr) if datestr and timestr and lat and lon: in_kml = ' in kml' if datestr not in places: places[datestr] = {} timefile = timestr + filebase if timefile not in places[datestr]: places[datestr][timefile] = {} jpegmeta = places[datestr][timefile] jpegmeta['filebase'] = filebase jpegmeta['time'] = GX.when('T'.join(datestr, timestr)) jpegmeta['place'] = \ GX.coord('{0} {1} {2}'.format(lon, lat, alt)) jpegmeta['point'] = \ KML.Point( KML.coordinates('{0},{1},{2}'.format\ (lon, lat, 0))) if self.config['arguments']['url']: jpegmeta['fileurl'] = '/'.join( self.config['arguments']['url'], basedir, f) else: jpegmeta['fileurl'] = '/'.join('file:/', filepath) if self.verbosity > 0: print(' ' + f, in_kml, file=sys.stderr) # Build the track folder and placemark folder track_folder = KML.Folder() image_folder = KML.Folder() for datestr in sorted(places.keys()): colourID = '#colour' + str(self.colourIndex) placemark = KML.Placemark( KML.visibility('1'), KML.name(basedir), KML.description('Path taken at ' + basedir + ' on ' + datestr), KML.styleUrl(colourID) ) self.colourIndex = (self.colourIndex + 1) % self.colourSetLen track = GX.Track( KML.altitudeMode('clampToGround') ) for tf in sorted(places[datestr].keys()): # append when elements track.append(places[datestr][tf]['time']) for tf in sorted(places[datestr].keys()): # append coord elements track.append(jpegmeta[tf]['place']) placemark.append(track) track_folder.append(placemark) for tf in sorted(places[datestr].keys()): jpegmeta = places[datestr][tf] jpg = jpegmeta['filebase'] cdatakey = 'CDATA' + directory + datestr + jpg self.cdatatext[cdatakey] = ('<![CDATA[<img src="' + jpegmeta['fileurl'] + ' width=400/><br/>' + 'Taken at ' + directory + ' on ' + datestr + '<br/>]]>') image_folder.append( KML.Placemark( KML.visibility('1'), KML.styleUrl('#picture'), KML.name(jpg), KML.description('{' + cdatakey + '}'), jpegmeta['point'] ) ) doc.append(track_folder) doc.append(image_folder)