def makekml(t, lonLatAlt, lat0, lon0, ofn=None): assert isinstance( lonLatAlt, np.ndarray) and lonLatAlt.ndim == 2 and lonLatAlt.shape[1] == 3 kml = Kml(name='My Kml') # doc = kml.newdocument(name='My Doc',snippet=Snippet('snippet')) # doc.lookat.gxtimespan.begin = t[0] # doc.lookat.gxtimespan.end = t[-1] # doc.lookat.latitude = lat0 # doc.lookat.longitude = lon0 # doc.lookat.range = 1e3 #fol = kml.newfolder(name='My Tracks') trk = kml.newgxtrack(name='My Track') trk.newwhen(t) trk.newgxcoord(lonLatAlt.tolist()) #list of lon,lat,alt, NOT ndarray! # Styling (from simplekml docs) # trk.stylemap.normalstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' # trk.stylemap.normalstyle.linestyle.color = '99ffac59' # trk.stylemap.normalstyle.linestyle.width = 6 # trk.stylemap.highlightstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' # trk.stylemap.highlightstyle.iconstyle.scale = 1.2 # trk.stylemap.highlightstyle.linestyle.color = '99ffac59' # trk.stylemap.highlightstyle.linestyle.width = 8 if not ofn: ofn = mkstemp(suffix='.kml')[1] print('writing to', ofn) kml.save(str(ofn))
def get_kml(self, app_session): kml = Kml() # set up map points for Plants plants_folder = kml.newfolder(name="Potential Facilities") plants_points = [ plants_folder.newpoint(name=plant.name, coords=[(plant.longitude, plant.latitude)]) for plant in app_session.data_set.query(Plant).all() ] for p in plants_points: p.style = plant_style # set up map points for Shops shops_folder = kml.newfolder(name="Shops") shops_points = [ shops_folder.newpoint(name=shop.name, coords=[(shop.longitude, shop.latitude)]) for shop in app_session.data_set.query(Shop).all() ] for p in shops_points: p.style = shop_style return kml.kml()
def test_kml_simple(self): coordinates = [ (-76.0, 38.0, 0.0), (-76.0, 38.0, 10.0), (-76.0, 38.0, 20.0), (-76.0, 38.0, 30.0), (-76.0, 38.0, 100.0), (-76.0, 38.0, 30.0), (-76.0, 38.0, 60.0), ] # Create Coordinates start = TakeoffOrLandingEvent(user=self.user, uas_in_air=True) start.save() for coord in coordinates: self.create_log_element(*coord) end = TakeoffOrLandingEvent(user=self.user, uas_in_air=False) end.save() kml = Kml() UasTelemetry.kml(user=self.user, logs=UasTelemetry.by_user(self.user), kml=kml, kml_doc=kml) for coord in coordinates: tag = self.coord_format.format(coord[1], coord[0], units.feet_to_meters(coord[2])) self.assertTrue(tag in kml.kml())
def exportToKml(): # KML kml = Kml() for aMergedWayTupleKey in tramRoutes: aMergedWayTuple = tramRoutes[aMergedWayTupleKey] aMergedWay = aMergedWayTuple[1] lineNames = ','.join(aMergedWayTuple[0]) coords = list() for aCoordTuple in aMergedWay: lat = aCoordTuple[0] lon = aCoordTuple[1] coords.append((lon, lat)) lin = kml.newlinestring(name="Pathway", description='-', coords=coords) r = lambda: random.randint(0, 255) randomColor = '#ff%02X%02X%02X' % (r(), r(), r()) lin.style.linestyle.color = randomColor lin.style.linestyle.width = 10 # 10 pixels kml.save("singlestyle.kml")
def exportToKml2(): # KML kml = Kml() for aGroupedWayKey in subRoutes: aGroupedWay = subRoutes[aGroupedWayKey][0] lineNames = ','.join(aGroupedWay.lines) coords = list() for aNodeKey in aGroupedWay.nodesList: if type(aNodeKey) is str: aNode = nodesDict[aNodeKey] lat = aNode.lat lon = aNode.lon elif type(aNodeKey) is OsmNode: lat = aNodeKey.lat lon = aNodeKey.lon else: lat = aNodeKey[0] lon = aNodeKey[1] coords.append((lon, lat)) lin = kml.newlinestring(name="Pathway", description='-', coords=coords) r = lambda: random.randint(0, 255) randomColor = '#ff%02X%02X%02X' % (r(), r(), r()) #random ARGB color lin.style.linestyle.color = randomColor lin.style.linestyle.width = 10 # 10 pixels kml.save("singlestyle.kml")
def google_earth_export(): print('ttt'*100, request.form) form = GoogleEarthForm(request.form) if 'POST' in request.method: kml_file = Kml() for node in filter(lambda obj: obj.visible, Node.query.all()): point = kml_file.newpoint(name=node.name) point.coords = [(node.longitude, node.latitude)] point.style = styles[node.subtype] point.style.labelstyle.scale = request.form['label_size'] for link in filter(lambda obj: obj.visible, Link.query.all()): line = kml_file.newlinestring(name=link.name) line.coords = [ (link.source.longitude, link.source.latitude), (link.destination.longitude, link.destination.latitude) ] line.style = styles[link.type] line.style.linestyle.width = request.form['line_width'] filepath = join(current_app.kmz_path, request.form['name'] + '.kmz') kml_file.save(filepath) return render_template( 'google_earth_export.html', form=form )
def get_kml(self, app_session): kml = Kml() stores = app_session.data_set.query(Store).all() for store in stores: kml.newpoint(name=store.name, coords=[(store.longitude, store.latitude)]) return kml.kml()
def main(args, options): global DEBUG DEBUG = options.debug global VERBOSE VERBOSE = options.verbose kml = Kml() kml.document.name = "GPX Extent Map created by pqmap.py on %s" % datetime.now() count = 0 for arg in args: if DEBUG or VERBOSE: print("arg: %s" % arg) for globname in glob(arg): count += process_arg(kml, globname) document_name = os.path.join(BASEDIR, DOCUMENT_NAME) kml.save(document_name) if not options.verbose: print() print("%d .gpx files processed" % count) print("Output is in %s" % document_name)
def prep_wind_kml_per_hour(data_to_show): ### create the kml file kml = Kml(open=1) ### name columns according to hour of day lon_col = "lon" lat_col = "lat" data_col = "data" ### create lines that represent thermals ### calculate centre of the small grid ### place the line segment in the centre ### take wind speed and direction and calculate coordinates ### of the end point of the line segment ### add the arrow pointer for i in range(1, len(data_to_show) - 1): x1 = -data_to_show[lon_col][i] y1 = data_to_show[lat_col][i] z1 = data_to_show[data_col][i] x2 = -data_to_show[lon_col][i + 1] y2 = data_to_show[lat_col][i + 1] z2 = data_to_show[data_col][i + 1] if z1 > 0 or z2 > 0: line_name = "line " + str(i) linestring = kml.newlinestring(name=line_name) linestring.coords = [(x1, y1), (x2, y2)] linestring.altitudemode = simplekml.AltitudeMode.relativetoground linestring.style.linestyle.width = 10 linestring.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' linestring.style.linestyle.color = '99ffac59' kml_file_name = "Roldanillo_wind.kml" kml.save(path2grid + "hours\\" + kml_file_name)
def main(): """Compute longitude to fit with computed latitude and checksum.""" kml = Kml() kml.newpoint(name="Vitts Mill", coords=[(HOME[1], HOME[0])]) kml.newpoint(name="Vitts Mill WP2", coords=[(WP2[1], WP2[0])]) # known values for A, B, C lat = "N38 27.%d%d%d" % (A, B, C) clat = convert(lat) # all answers sum to 24 leftovers = 24 - (A + B + C) # compute all values for D, E and F for D in range(10): if D > leftovers: continue for E in range(10): if (D + E) > leftovers: continue for F in range(10): if D + E + F == leftovers: lon = "W91 00.%d%d%d" % (D, E, F) clon = convert(lon) here = (clat, clon) # compute distance from posted coordinates d = vincenty(HOME, here).miles print(d, lat, lon) name = "loc_%d%d%d%d%d%d" % (A, B, C, D, E, F) kml.newpoint(name=name, coords=[(clon, clat)]) kml.save(FILENAME) print("Output is in %s" % FILENAME)
def prep_sink_kml_per_hour(hours, data_to_show): for hour in hours: ### create the kml file kml = Kml(open=1) ### name columns according to hour of day lon_col = "lon" + str(hour) lat_col = "lat" + str(hour) data_col = "data" + str(hour) ### create lines that represent thermals for i in range(len(data_to_show) - 1): x1 = -data_to_show[lon_col][i] y1 = data_to_show[lat_col][i] z1 = data_to_show[data_col][i] x2 = -data_to_show[lon_col][i + 1] y2 = data_to_show[lat_col][i + 1] z2 = data_to_show[data_col][i + 1] if z1 < -100 or z2 < -100: line_name = "line " + str(i) linestring = kml.newlinestring(name=line_name) linestring.coords = [(x1, y1), (x2, y2)] linestring.altitudemode = simplekml.AltitudeMode.absolute linestring.style.linestyle.width = 3 if z1 > -200 or z2 > -200: linestring.style.linestyle.color = simplekml.Color.green elif z1 > -400 or z2 > -400: linestring.style.linestyle.color = simplekml.Color.blue linestring.style.linestyle.width = 6 else: linestring.style.linestyle.color = simplekml.Color.black linestring.style.linestyle.width = 9 ### linestring.extrude = 1 kml_file_name = "Roldanillo_" + str(hour) + "_sinks.kml" kml.save(path2grid + "hours\\" + kml_file_name)
def get_kml(self, app_session): kml = Kml() person_style = Style(iconstyle=IconStyle( scale=0.8, icon=Icon( href= 'https://maps.google.com/mapfiles/kml/paddle/blu-circle-lv.png' ))) people_folder = kml.newfolder(name="Potential Facilities") for p in [ people_folder.newpoint(name=person.name, coords=[(person.longitude, person.latitude)]) for person in app_session.data_set.query(Person).all() ]: p.style = person_style place_style = Style(iconstyle=IconStyle( scale=0.4, icon=Icon( href= 'https://maps.google.com/mapfiles/kml/paddle/red-circle-lv.png' ))) places_folder = kml.newfolder(name="Places") for p in [ places_folder.newpoint(name=place.name, coords=[(place.longitude, place.latitude)]) for place in app_session.data_set.query(Place).all() ]: p.style = place_style return kml.kml()
def main(): global options, args if options.list_colors: create_color_map(COLOR_TABLE) sys.exit() output_filename = options.output kml = Kml() kml.document.name = "Test of kmldraw.py" for line in RAWINPUT[1:-1].split('\n'): text, quad = line.split("\t") name = text.strip() import re result = re.match( '\((\d+.\d+), (\d+.\d+), (-\d+.\d+), (-\d+.\d+)\)', quad) minlat, maxlat, minlon, maxlon = list(map(float, result.groups())) quad = (minlat, maxlat, minlon, maxlon) kmldraw(kml, name, quad) kml.save(output_filename) print("Wrote to: %s" % output_filename)
def test_kml_simple(self): coordinates = [ (0, -76.0, 38.0, 0.0, 0), (1, -76.0, 38.0, 10.0, 0), (2, -76.0, 38.0, 20.0, 0), (3, -76.0, 38.0, 30.0, 0), (4, -76.0, 38.0, 100.0, 0), (5, -76.0, 38.0, 30.0, 0), (6, -76.0, 38.0, 60.0, 0), ] # Create Coordinates start = TakeoffOrLandingEvent(user=self.user, uas_in_air=True) start.save() start.timestamp = self.now start.save() for coord in coordinates: self.create_log_element(*coord) end = TakeoffOrLandingEvent(user=self.user, uas_in_air=False) end.save() end.timestamp = self.now + datetime.timedelta(seconds=7) end.save() kml = Kml() UasTelemetry.kml( user=self.user, logs=UasTelemetry.by_user(self.user), kml=kml, kml_doc=kml.document) for coord in coordinates: tag = self.coord_format.format(coord[2], coord[1], units.feet_to_meters(coord[3])) self.assertTrue(tag in kml.kml())
def get_kml(self, app_session): kml = Kml() node_style = Style(iconstyle=IconStyle(scale=0.8, icon=Icon( href='https://maps.google.com/mapfiles/kml/paddle/blu-circle-lv.png'))) node_folder = kml.newfolder(name="Nodes") for p in [node_folder.newpoint(name=n.name, coords=[(n.longitude, n.latitude)]) for n in app_session.data_set.query(Node).all()]: p.style = node_style node_index = {} node_counter = 0 arc_folder = kml.newfolder(name="Arcs") for flow in app_session.data_set.query(NetworkFlow).all(): if not node_index.get(flow.orig_name, None): node_index.update({flow.orig_name: node_counter}) node_counter += 1 arc_style = Style( linestyle=LineStyle(color=MapFlowOutput.get_cycled_hex_colour(node_index.get(flow.orig_name)), width=4)) l = arc_folder.newlinestring(name="arc", coords=[(flow.orig_node.longitude, flow.orig_node.latitude), (flow.dest_node.longitude, flow.dest_node.latitude)]) l.style = arc_style return kml.kml()
def test_kml_empty(self): kml = Kml() UasTelemetry.kml( user=self.user, logs=UasTelemetry.by_user(self.user), kml=kml, kml_doc=kml.document)
def density_kml(kml_path, city, dicts, borders, scaling=(lambda x: x)): def rgb_to_bgr(color): return "{rgb[4]}{rgb[5]}{rgb[2]}{rgb[3]}{rgb[0]}{rgb[1]}".format( rgb=color) def add_folder(kml, data): def cell_to_color(value, color, scaling): norm_value = scaling(value) return '{0:02x}{1}'.format(int(norm_value * 200), color) folder_dict = data['dict'] # normalizing maximum = data['max'] norm_scaling = lambda x: scaling(x / maximum) # make a kml of polygons folder = kml.newfolder(name=data['name']) color = rgb_to_bgr(data['color']) folder = dict_to_kml(folder, borders, folder_dict, cell_to_color, color, norm_scaling) return kml kml = Kml() for data in dicts: kml = add_folder(kml, data) kml.save(kml_path)
def process(): distances = sorted(compute_distances()) # thin out the result by taking every 50th distance THIN = 50 distances = distances[::THIN] pprint(distances) bearings = compute_bearings() locations = compute_locations(distances, bearings) points = compute_points(locations) kml = Kml() for distance, bearing, lat, lon in points: name = "d_%s_b_%s" % (distance, bearing) kml.newpoint( name=name, coords=[(lon, lat)] ) kml.save("ayhe11.kml")
def graph_kml( env, fname="graph.kml", icon="http://maps.google.com/mapfiles/kml/shapes/donut.png", size=0.5, scale=0.5, width=5, ): """Create a kml visualisation of graph. Env variable needs to contain graph.""" # create a kml file containing the visualisation kml = Kml() fol = kml.newfolder(name="Vessels") shared_style = Style() shared_style.labelstyle.color = "ffffffff" # White shared_style.labelstyle.scale = size shared_style.iconstyle.color = "ffffffff" # White shared_style.iconstyle.scale = scale shared_style.iconstyle.icon.href = icon shared_style.linestyle.color = "ff0055ff" # Red shared_style.linestyle.width = width nodes = list(env.FG.nodes) # each timestep will be represented as a single point for log_index, value in enumerate(list(env.FG.nodes)[0 : -1 - 1]): pnt = fol.newpoint( name="", coords=[ ( nx.get_node_attributes(env.FG, "Geometry")[nodes[log_index]].x, nx.get_node_attributes(env.FG, "Geometry")[nodes[log_index]].y, ) ], ) pnt.style = shared_style edges = list(env.FG.edges) for log_index, value in enumerate(list(env.FG.edges)[0 : -1 - 1]): lne = fol.newlinestring( name="", coords=[ ( nx.get_node_attributes(env.FG, "Geometry")[edges[log_index][0]].x, nx.get_node_attributes(env.FG, "Geometry")[edges[log_index][0]].y, ), ( nx.get_node_attributes(env.FG, "Geometry")[edges[log_index][1]].x, nx.get_node_attributes(env.FG, "Geometry")[edges[log_index][1]].y, ), ], ) lne.style = shared_style kml.save(fname)
def test_sets_coords(self): """ The coords are private variables, so they can't be tested directly. Instead this test just checks they exist """ kml = Kml() point = self.scraper.create_point(kml, self.sample_row1) self.assertIsInstance(point.coords, Coordinates)
def generate_kml(): """Generate KML file from geojson.""" uuid = request.values.get('uuid', None) campaign_name = request.values.get('campaign_name', None) campaign = Campaign(uuid) # Get json for each type. types = campaign.get_s3_types() if types is None: return Response(json.dumps({'error': 'types not found'}), 400) data = [] for t in types: data.append(campaign.get_type_geojsons(t)) if len(data) == 0: return Response(json.dumps({'error': 'Data not found'}), 400) features = [i['features'] for sublist in data for i in sublist] # for each type, we need to get geojson. kml = Kml(name=campaign_name) file_name = hashlib.md5( uuid.encode('utf-8') + '{:%m-%d-%Y}'.format(datetime.today()).encode( 'utf-8')).hexdigest() + '.kml' file_path = os.path.join(config.CACHE_DIR, file_name) # For now, let's work only with points. # TODO: include polygons in the kml file. features = [[f for f in sublist if f['geometry']['type'] == 'Point'] for sublist in features] features = [item for sublist in features for item in sublist] for feature in features: tags = feature['properties']['tags'] extended_data = ExtendedData() kml_name = '' if 'name' in tags.keys(): kml_name = tags['name'] elif 'amenity' in tags.keys(): kml_name = tags['amenity'] [ extended_data.newdata(k, escape(v)) for k, v in tags.items() if k != 'name' ] kml.newpoint(name=kml_name, extendeddata=extended_data, coords=[(feature['geometry']['coordinates'][0], feature['geometry']['coordinates'][1])]) kml.save(path=file_path) if kml: # Save file into client storage device. return Response(json.dumps({'file_name': file_name}))
def action(dependencies, targets): """ :param dependencies: list of files to process :param targets: list of file to output :return: """ kml = Kml() ship = kml.newdocument(name='ship') camera = kml.newdocument(name='camera') inputs = list(dependencies) inputs.sort() for dep in inputs: log = pd.read_csv(dep, index_col='timestamp', parse_dates=['timestamp']) log = log.resample('10S').first() log['Time'] = log.index log['Depth'] = 0 item = log.iloc[0] track = ship.newgxtrack( name=f'operation {int(item.Operation):03d}', altitudemode=AltitudeMode.clamptoground, description=f'Site {item.Site}') track.stylemap.normalstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' track.stylemap.normalstyle.linestyle.color = Color.green track.stylemap.normalstyle.linestyle.width = 6 track.stylemap.highlightstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' track.stylemap.highlightstyle.iconstyle.scale = 1.2 track.stylemap.highlightstyle.linestyle.color = '99ffac59' track.stylemap.highlightstyle.linestyle.width = 8 track.newgxcoord( list( zip(log.ShipLongitude.interpolate().values, log.ShipLatitude.interpolate().values, log.Depth.interpolate()))) track.newwhen( list(log.Time.dt.strftime('%Y-%m-%dT%H:%M:%S').values)) track = camera.newgxtrack( name=f'operation {int(item.Operation):03d}', altitudemode=AltitudeMode.relativetoground, description=f'Site {item.Site}') track.newgxcoord( list( zip(log.UsblLongitude.interpolate(), log.UsblLatitude.interpolate(), -log.HSVPressure))) track.newwhen( list(log.Time.dt.strftime('%Y-%m-%dT%H:%M:%S').values)) track.stylemap.normalstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' track.stylemap.normalstyle.linestyle.color = Color.red track.stylemap.normalstyle.linestyle.width = 6 track.stylemap.highlightstyle.iconstyle.icon.href = 'http://earth.google.com/images/kml-icons/track-directional/track-0.png' track.stylemap.highlightstyle.iconstyle.scale = 1.2 track.stylemap.highlightstyle.linestyle.color = '99ffac59' track.stylemap.highlightstyle.linestyle.width = 8 kml.save(list(targets)[0])
def create_lines_and_base_obj(self, msg_list): """ Returns KML object with a chain of lines representing the order in which msg_list items are indexed. """ kml = Kml() for i in range(1, len(msg_list)): self.create_line_sgmnt(kml, msg_list[i - 1], msg_list[i]) return kml
def make_kml(llcrnrlon, llcrnrlat, urcrnrlon, urcrnrlat, figs, colorbar=None, **kw): """TODO: LatLon bbox, list of figs, optional colorbar figure, and several simplekml kw...""" kml = Kml() altitude = kw.pop('altitude', 1e0) #2e7) roll = kw.pop('roll', 0) tilt = kw.pop('tilt', 0) altitudemode = kw.pop('altitudemode', AltitudeMode.relativetoground) camera = Camera(latitude=np.mean([urcrnrlat, llcrnrlat]), longitude=np.mean([urcrnrlon, llcrnrlon]), altitude=altitude, roll=roll, tilt=tilt, altitudemode=altitudemode) kml.document.camera = camera draworder = 0 for fig in figs: # NOTE: Overlays are limited to the same bbox. draworder += 1 ground = kml.newgroundoverlay(name='GroundOverlay') ground.draworder = draworder ground.visibility = kw.pop('visibility', 1) ground.name = kw.pop('name', 'overlay') #ground.color = kw.pop('color', '9effffff') ##kw.pop('color', '9effffff') ground.atomauthor = kw.pop('author', 'PyHum') ground.latlonbox.rotation = kw.pop('rotation', 0) ground.description = kw.pop('description', 'Matplotlib figure') ground.gxaltitudemode = kw.pop('gxaltitudemode', 'clampToSeaFloor') ground.icon.href = fig ground.latlonbox.east = llcrnrlon ground.latlonbox.south = llcrnrlat ground.latlonbox.north = urcrnrlat ground.latlonbox.west = urcrnrlon if colorbar: # Options for colorbar are hard-coded (to avoid a big mess). screen = kml.newscreenoverlay(name='ScreenOverlay') screen.icon.href = colorbar screen.overlayxy = OverlayXY(x=0, y=0, xunits=Units.fraction, yunits=Units.fraction) screen.screenxy = ScreenXY(x=0.015, y=0.075, xunits=Units.fraction, yunits=Units.fraction) screen.rotationXY = RotationXY(x=0.5, y=0.5, xunits=Units.fraction, yunits=Units.fraction) screen.size.x = 0 screen.size.y = 0 screen.size.xunits = Units.fraction screen.size.yunits = Units.fraction screen.visibility = 1 kmzfile = kw.pop('kmzfile', 'overlay.kmz') kml.savekmz(kmzfile)
def export_to_kml(self, file_name): coords = list() for i in range(len(self._gps_latitude)): coords.append((self._gps_longitude[i], self._gps_latitude[i])) kml = Kml() lin = kml.newlinestring(name="Track", description="A track.", coords=coords) lin.style.linestyle.color = 'ff0000ff' # Red lin.style.linestyle.width = 2 # 10 pixels kml.save(file_name)
def get_kml(self, app_session): kml = Kml() node_style = Style(iconstyle=IconStyle(scale=0.8, icon=Icon( href='https://maps.google.com/mapfiles/kml/paddle/blu-circle-lv.png'))) node_folder = kml.newfolder(name="Nodes") for p in [node_folder.newpoint(name=n.name, coords=[(n.longitude, n.latitude)]) for n in app_session.data_set.query(Node).all()]: p.style = node_style return kml.kml()
def create_color_map(color_list): kml = Kml() lat = 38.000 init_lon = lon = -90.000 extent = 0.02 for index, color in enumerate(color_list): add_patch(kml, lat, lon, extent, color) lon += extent if (index % 10) == 9: lon = init_lon lat -= extent kml.save("color_patches.kml") print("Output in color_patches.kml")
def get_kml(self, app_session): kml = Kml() def LongLat(l): return (l.longitude, l.latitude) mylocstyle = Style(iconstyle=IconStyle( scale=0.8, icon=Icon( href= 'https://maps.google.com/mapfiles/kml/paddle/blu-circle-lv.png' ))) LocsFolder = kml.newfolder(name="Locations") locations = app_session.data_set.query(Location).all() if len(locations) < 100: for p in [ LocsFolder.newpoint(name=loc.name, coords=[LongLat(loc)]) for loc in locations ]: p.style = mylocstyle mylinestyle = Style(linestyle=LineStyle(color='FF0000FF', width=4)) PathsFolder = kml.newfolder(name="Paths") paths = app_session.data_set.query(Path).all() if len(paths) < 100: for path in [ PathsFolder.newlinestring(name='path', coords=[ LongLat(l.start_location), LongLat(l.end_location) ]) for l in paths ]: path.style = mylinestyle mylinestyle = Style(linestyle=LineStyle(color='FF00FF00', width=4)) PathsFolder = kml.newfolder(name="Paths") paths = app_session.data_set.query(OutputPath).all() if len(paths) < 100: for path in [ PathsFolder.newlinestring(name='path', coords=[ LongLat(l.start_location), LongLat(l.end_location) ]) for l in paths ]: path.style = mylinestyle return kml.kml()
def flask_get_kml(): """ Return KML with autorefresh """ _config = autorx.config.global_config kml = Kml() netlink = kml.newnetworklink(name="Radiosonde Auto-RX Live Telemetry") netlink.open = 1 netlink.link.href = flask.request.host_url + "rs_feed.kml" try: netlink.link.refreshinterval = _config["kml_refresh_rate"] except KeyError: netlink.link.refreshinterval = 10 netlink.link.refreshmode = "onInterval" return kml.kml(), 200, {"content-type": "application/vnd.google-earth.kml+xml"}
def test_line_sgmnt(self): """ The segment specs are private variables. This tests whetehr line segments can be made. """ sample_row2 = self.convert_list_to_etree([ '913686008', '0-2440482', 'Lima', '1517940807', 'UNLIMITED-TRACK', '-8.74288', '-74.43631', 'SPOT3', 'Y', '2018-02-06T18:13:27+0000', 'GOOD', '0', '2027' ]) kml = Kml() line = self.scraper.create_line_sgmnt(kml, self.sample_row1, sample_row2) self.assertIsInstance(line, LineString)