def write_kml(self): """Write KML file.""" make_dir_if_not_exist(self.output_dir) # shamefully dump as JSON then unmarshal into a dict -- sigh. peak_dict = json.loads(self.tablib_data.export('json')) k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' # Create a KML Document and add it to the KML root object d = kml.Document(ns, self.filename, self.filename, 'pinmap for {}'.format(self.filename)) k.append(d) kmlFolder =\ kml.Folder(ns, self.filename, self.filename, 'kml map of list points for {}'.format(self.filename)) for peak in peak_dict: details = '' for key, val in sorted(peak.items()): details += '{}: {}\n'.format(key, val) p = kml.Placemark(ns, peak['Name'], peak['Name'], details) p.geometry = Point(peak['Longitude'], peak['Latitude']) kmlFolder.append(p) d.append(kmlFolder) with open('{}.kml'.format(self.output_file), 'w') as output_kml: output_kml.write(k.to_string(prettyprint=True))
def kml_netlink(uri: str) -> str: ns = '{http://www.opengis.net/kml/2.2}' k = kml.KML(ns) d = kml.Document(ns, name="explorer tiles netlink") k.append(d) class NetworkLink(kml.Document): __name__ = 'NetworkLink' def __init__(self, ns=None, name=None, href=None): super().__init__(ns=ns, name=name) self._href = href def etree_element(self): href = kml.etree.Element(ns + "href") href.text = self._href link = kml.etree.Element(ns + "Link") link.append(href) e = super().etree_element() e.append(link) return e n = NetworkLink(ns, name="explorer tiles", href=uri) d.append(n) return k.to_string(prettyprint=True)
def write_kml(): print('=====') print('===== Building KML =====') k = kml.KML() # print(k) ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'docid', 'doc name', 'doc description') k.append(d) p = kml.Placemark(ns, 'id', 'name', 'description') # p.geometry = Polygon([(0,0,0), (1,1,0), (1,0,1)]) easting = 128.4 northing = 36.4 elevation = 0 # does Google Earth show points that are under terrain or buildings? # KML uses long, lat, alt for ordering coordinates (x, y, z) p.geometry = Point(easting, northing, elevation) d.append(p) # kml.Placemark print(k.to_string(prettyprint=True)) with open(kml_path, 'w') as f: f.write(k.to_string()) with open(kml_path, 'r') as f: print(f.read())
def _get_output_kml(self): outputkml = kml.KML() for doc in self.Documents: id = doc.id name = doc.name desc = doc.description outdoc = kml.Document(ns, id, name, desc) outputkml.append(outdoc) if isinstance(list(doc.features())[0], Placemark): out_nsfolders = self._setPlacemark_for_KML(doc.features()) for out_nsfolder in out_nsfolders: outdoc.append(out_nsfolder) else: for folder in doc.features(): id = folder.id name = folder.name desc = folder.description outfolder = kml.Folder(ns, id, name, desc) out_nsfolders = self._setPlacemark_for_KML( folder.features()) for out_nsfolder in out_nsfolders: outfolder.append(out_nsfolder) outdoc.append(outfolder) return outputkml
def write_to_kml(self,filename): k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns=ns, name='SNOPT Stitched Trajectory') #styles s = styles.Style(id='yellowLineGreenPoly') ls = styles.LineStyle(color='7f00ff00',width=4) ps = styles.PolyStyle(color='7f00ff00') s.append_style(ls) s.append_style(ps) d.append_style(s) #placemark pm = kml.Placemark(name='Stitched Trajectory',description='Trajectory for EADDDAS',styleUrl='#yellowLineGreenPoly') geom = Geometry() coords = [] for i,x in enumerate(self.east): coord = [0]*3 coord[1] = self.ka.lat + self.north[i]/111111.0 #lat coord[0] = self.ka.lon + self.east[i]/(111111.0*cos(coord[1]*pi/180)) #lon coord[2] = self.ka.alt + self.up[i] #alt coords.append(tuple(coord)) geom.geometry = LineString(coords) geom.extrude = True geom.tessellate = True geom.altitude_mode = 'absolute' pm.geometry = geom d.append(pm) k.append(d) kmlfile = open(filename,"w") kmlfile.write(k.to_string(prettyprint=True)) kmlfile.close()
def create_kml_for_placemark(placemark): # Create the root KML object k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' data = placemark.extended_data.elements[0].data datadict = {} for kv in data: datadict[kv['name']] = kv['value'] insee_dep = datadict['insee_dep'] nom_dep = datadict['nom_dep'] # Create a KML Document and add it to the KML root object d = kml.Document(ns, nom_dep, nom_dep, nom_dep) k.append(d) # Create a Placemark with a simple polygon geometry and add it to the # second folder of the Document d.append(placemark) if len(insee_dep) < 2: insee_dep = '0' + insee_dep filepath = os.path.join(GEN_ZONES, '{}-{}.kml'.format(insee_dep, nom_dep)) with open(filepath, 'w', encoding='utf-8') as myfile: myfile.write(k.to_string(prettyprint=True)) return insee_dep, filepath
def tiles_to_kml(tiles, filename, name): # Create the root KML object k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' s = styles.Style(id="s", styles=[styles.LineStyle(color="ff0000ff", width=1)]) # Create a KML Document and add it to the KML root object d = kml.Document(ns, name=name, styles=[s]) k.append(d) # Create a KML Folder and add it to the Document f = kml.Folder(ns, name=name) d.append(f) # Create a Placemark with a simple polygon geometry and add it to the # second folder of the Document for tile_id in tiles: tile = Tile(tile_id) p = kml.Placemark(ns, tile_id, styleUrl="#s") p.geometry = tile.line_string_lon_lat f.append(p) print(k.to_string(prettyprint=True)) with open(filename, 'w') as hf: hf.write(k.to_string(prettyprint=True)) return True
def search_target_kml(request, format=None): """ A view that returns a kml file for targets given a bounding box """ queryset = Target.objects.all() bounding_box = request.query_params['bounding_box'] if bounding_box == '': bounding_box = None if bounding_box is not None: queryset = queryset.filter(coordinates__coveredby=bounding_box) k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'docid', 'GHGSat Document', 'Display GHGSat targets') k.append(d) f = kml.Folder(ns, 'folder1', 'Targets', 'Targets features') d.append(f) for target in queryset: p = kml.Placemark(ns, str(target.id), str(target.name), 'description') p.geometry = Point(target.coordinates.x, target.coordinates.y, target.elevation) f.append(p) return Response(k.to_string(prettyprint=True))
def getKmlFromGeom(geom): # Create the root KML object k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' # Create a KML Document and add it to the KML root object d = kml.Document(ns) k.append(d) # Create a KML Folder and add it to the Document f = kml.Folder(ns) d.append(f) # Create a KML Folder and nest it in the first Folder nf = kml.Folder(ns) f.append(nf) # Create a second KML Folder within the Document f2 = kml.Folder(ns) d.append(f2) # Create a Placemark with a simple polygon geometry and add it to the # second folder of the Document p = kml.Placemark(ns) p.geometry = geom f2.append(p) return k.to_string()
def form_valid(self, form): k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'docid', 'San Francisco Observations', 'KML Document') f = kml.Folder(ns, 'fid', 'San Francisco Observations Root Folder', 'Contains place marks for specimens and observations.') k.append(d) d.append(f) os = Occurrence.objects.all() for o in os: if (o.geom): p = kml.Placemark(ns, 'id', 'name', 'description') #coord = utm.to_latlon(o.geom.coords[0], o.geom.coords[1], 37, 'P') pnt = Point(o.geom.coords[0], o.geom.coords[1]) p.name = o.__str__() d = "<![CDATA[<table>" openrow = "<tr><td>" middlerow = "</td><td style='font-weight:bold'>" closerow = "</td></tr>" d += openrow d += ''.join(("Basis of Record", middlerow)) d += ''.join( filter(None, (o.basis_of_record, closerow, openrow))) d += ''.join(("Time", middlerow)) d += ''.join( filter(None, (str(o.field_number), closerow, openrow))) d += ''.join(("Item Type", middlerow)) d += ''.join(filter(None, (o.item_type, closerow, openrow))) d += ''.join(("Collector", middlerow)) d += ''.join(filter(None, (o.collector, closerow, openrow))) d += ''.join(("Collection Method", middlerow)) d += ''.join( filter(None, (o.collecting_method, closerow, openrow))) d += ''.join(("Count", middlerow)) d += ''.join( filter(None, (str(o.individual_count), closerow, openrow))) d += ''.join(("Bar Code", middlerow)) d += ''.join(filter(None, (str(o.barcode), closerow, openrow))) d += ''.join(("Scientific Name", middlerow)) d += ''.join( filter(None, (o.item_scientific_name, closerow, openrow))) d += ''.join(("Description", middlerow)) d += ''.join( filter(None, (o.item_description, closerow, openrow))) d += ''.join(("Remarks", middlerow)) d += ''.join(filter(None, (o.remarks, closerow, openrow))) d += ''.join(("In Situ", middlerow)) d += ''.join(filter(None, (str(o.in_situ), closerow))) d += "</table>" p.description = d p.geometry = pnt f.append(p) r = k.to_string(prettyprint=True) response = HttpResponse(r, mimetype='text/plain') response[ 'Content-Disposition'] = 'attachment; filename="san_francisco.kml"' return response
def handle(self, *args, **options): """Slice and import the KML file.""" # Open the input file and get its features. startTime = datetime.now() print("Starting at:", startTime) with open(options['input'], 'rt') as kmlFile: doc = kmlFile.read() fileName, fileExtension = os.path.splitext(options['input']) k = kml.KML() k.from_string(doc.replace("xsd:", "").encode('UTF-8')) features = list(k.features()) features1 = list(features[0].features()) inputStyles = list(features[0].styles()) placemarks = list(features1[0].features()) # Prepare the output file. ns = '{http://www.opengis.net/kml/2.2}' output = kml.KML() d = kml.Document(ns, 'docid', 'doc name', 'doc description') d._styles = inputStyles output.append(d) f = kml.Folder(ns, 'fid', 'f name', 'f description') d.append(f) nf = kml.Folder(ns, 'nested-fid', 'nested f name', 'nested f description') f.append(nf) # remove old entries of the state: toDelete = Boundery.objects.filter(state=fileName) toDelete.delete() # Parallelize the processing. pool = Pool(processes=8) print("Processing ", len(placemarks), " Placemarks in the file.") chunks = [placemarks[i::10] for i in range(10)] result = pool.map(partial(slicePlacemarks, state=fileName), chunks) # summarize the results. for pm in result: for pl in pm[0]: print(pl) nf.append(pl) Boundery.objects.bulk_create(pm[2]) # dump the results into the output file. print("%s.%s" % (fileName, fileExtension)) text_file = open("%s_sliced%s" % (fileName, fileExtension), "w") outputString = output.to_string() text_file.write(outputString) text_file.close() # print the totals. print("Done within:", datetime.now() - startTime)
def handle(self, *args, **options): """Extract the results and write them into a KML files.""" startTime = datetime.now() boundaries = Boundery.objects.filter(isMain=False, processed=True) k = kml.KML() ns = "{http://www.opengis.net/kml/2.2}" d = kml.Document(ns, 'docid', "Results %s" % (startTime), 'doc description') k.append(d) f = kml.Folder(ns, 'fid', 'all objects', 'main folder') d.append(f) style = kml.Style(ns=ns, id="KMLStyler") polyStyle = styles.PolyStyle(id="polystyle", color="7fe1ca9e") style.append_style(polyStyle) k._features[0]._styles.append(style) print(list(k.features())) for boundary in boundaries: boundaryFolder = kml.Folder( ns, 'fid', boundary.matchingId, "Found features: %s" % (boundary.address_set.count())) boundaryPolygon = kml.Placemark( ns, boundary.matchingId, boundary.matchingId, "Found features: %s" % (boundary.address_set.count())) boundaryPolygon.geometry = Polygon(list( boundary.polygon.coords[0])) boundaryPolygon.styleUrl = "KMLStyler" boundaryFolder.append(boundaryPolygon) if (options['addresses']): for address in boundary.address_set.all(): p = kml.Placemark( ns, str(address.id), address.formattedAddress, "confidence: %s" % (str(address.confidence))) p.geometry = Point(address.point.coords) p.styleUrl = "KMLStyler" p.visibility = 0 boundaryFolder.append(p) f.append(boundaryFolder) text_file = open("./processed.kml", "w") outputString = k.to_string() text_file.write(outputString) text_file.close() print("Exporting:", boundaries.count()) print("Done within:", datetime.now() - startTime)
def get_kml(self): ''' Render the Site as KML ''' k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' ls = LineStyle(color="ffffff00", width=0.5) s1 = Style(id="thin_border", styles=[ls]) d = kml.Document(ns, self.site.name, self.site.name, "Site plan for %s" % (self.site.name), styles=[s1]) k.append(d) # nf = kml.Folder(ns, 'B1', 'building 1', 'Building one') # d.append(nf) # render the site reference mark as a KML Placemark p = kml.Placemark(ns, 'ref_mark', self.site.name, 'Reference survey mark') p.geometry = self.site.ref_mark d.append(p) # compute the UTM coords of the Site reference point crs = get_epsg(self.site.ref_mark) site_UTM = get_UTM_from_long_lat(self.site.ref_mark) project_UTM_to_WGS84 = partial(pyproj.transform, pyproj.Proj(init=crs), pyproj.Proj(init='epsg:4326')) folder = kml.Folder(ns, 'Structures', 'Structures', 'Structures on the site') d.append(folder) # render each Structure for s in self.site.structures: name = s.name # work with the outline of the structure outline = s.geometry.buffer(0) # move outline into UTM coordinates for the site outline = translate(outline, xoff=site_UTM.x, yoff=site_UTM.y) # and transform to WGS84 outline = transform(project_UTM_to_WGS84, outline) # place the outline in Structures folder p = kml.Placemark(ns, name, name, s.description, styleUrl="#thin_border") p.geometry = outline folder.append(p) # return the KML return k.to_string(prettyprint=True)
def colorizedGlyph(data, folderPath, docname, nbins, limits, cmap_type): # data: a numpy matrix with [latitude, longitude, height, f] in each row. Where f is the variable asociated with the color. # folderPath: a string with the folder path # nbins: number of beans of the color map # limits: a list [min, max] which are the limits of our color scale. # cmap_type: a string with the name of the colormap. Read matplotlib.cm reference for further information. colormap = cm.get_cmap(cmap_type, nbins) # Create the root KML object k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' # Create a KML Document and add it to the KML root object docid='' docdescription='This file was generated automaticaly with fastKML to colorize the aeroglyph.' kdoc = kml.Document(ns, docid, docname, docdescription) k.append(kdoc) # Create a KML Folder and add it to the Document folder1 = kml.Folder(ns, '', 'aeroglyph', '') kdoc.append(folder1) puntoPrev=[] idPunto=0 for punto in data: if(idPunto!=0): u=(punto[3]-limits[0])/(limits[1]-limits[0]) uprev=(puntoPrev[3]-limits[0])/(limits[1]-limits[0]) u=(u+uprev)/2 rgbcolor=colormap(u) hexcolor=colors.to_hex(rgbcolor, keep_alpha=True) hexcolor=hexcolor[-2:]+hexcolor[1:7] # Create a Placemark with a LineString geometry and add it to the Document estilolinea = styles.LineStyle(ns, color=hexcolor, width=4) estilo = styles.Style(styles=[estilolinea]) p = kml.Placemark(ns, str(idPunto), styles=[estilo]) p.geometry = LineString([puntoPrev[0:3], punto[0:3]]) # _geometry attribute is supposed not to be accessed directly # we have to look for a better solution using fastkml functions. p._geometry.altitude_mode='absolute' folder1.append(p) puntoPrev=punto idPunto+=1 # write kml buffer to our file. fileHandle= open(folderPath+docname+'.kml',"w+") fileHandle.write(k.to_string(prettyprint=True)) fileHandle.close()
def export(filename: str): global current_document kml_tree = kml.KML() current_document = kml.Document() yield current_document kml_tree.append(current_document) with open(filename, "w", encoding="utf8") as kml_file: kml_file.write(kml_tree.to_string(prettyprint=True)) _stylemap.clear() current_document = None
def write_kml(messages, output_filename): """ Sort messages on timestamp, convert to KML and write to disk """ # Sort since when saving to a file on the watch, they may be out of order messages.sort(key=lambda x: x.epoch) # Create KML file k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'watch-loc-data', 'Watch location data') k.append(d) f = kml.Folder(ns, 'all-data', 'All location data') d.append(f) s = [ kml.Style(ns, 'styles', [ styles.LineStyle(ns, 'linestyle', 'FF0000FF', width=2), styles.PolyStyle(ns, 'polystyle', '00FFFFFF'), ]) ] i = 0 pt_prev = None ts_prev = None for msg in messages: if msg.message_type == SensorData.MESSAGE_TYPE_LOCATION: # Skip if invalid lat/lon/alt value if msg.longitude == 0.0 and msg.latitude == 0.0 and msg.horiz_acc == 0.0: continue if msg.altitude == 0.0 and msg.vert_acc == 0.0: continue ts = datetime.fromtimestamp(msg.epoch) pt = (msg.longitude, msg.latitude, msg.altitude) # We're drawing lines between points, so skip the first point if i != 0: p = kml.Placemark(ns, 'point-' + str(i), 'point-' + str(i), styles=s) p.geometry = geometry.Geometry(ns, 'geometry-' + str(i), geometry.Polygon( [pt_prev, pt, pt, pt_prev]), altitude_mode='absolute') p.begin = ts_prev p.end = ts f.append(p) i += 1 pt_prev = pt ts_prev = ts with open(output_filename, "w") as f: f.write(k.to_string(prettyprint=True))
def document(name='', description='', shapes=[]): k = kml.KML() d = kml.Document(VERSION, 'root', 'Boxes', '') k.append(d) f = kml.Folder(VERSION, 'content', name, description) d.append(f) for shape in shapes: f.append(shape) return k
def main(): # read all the EXIF data from the target folder (or webserver?) # generate a KML with points # date-time of photo # any other EXIF data # make a KMZ that includes the photos (or URL to show the photo in Google Earth) # 2 approaches: # 1. Batch process everything in phases, doing one action to all the objects # 2. Process each item individually through the phases. DevOps = small batch size # Going with option 2. # initialize the KML document k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'docid', 'doc name', 'doc description') # TODO update fields k.append(d) files = [] for (dirpath, dirnames, filesnames) in walk(target): path_filenames = [] for file in filesnames: path_filenames.append(dirpath + file) files.extend(path_filenames) break # call to walk only the top directory for file in files: # print(file) # read EXIF # with open(file) as f: # exifread takes filenames # tags = exifread.process_file(file) # exifgps can open files also # convert EXIF coordinate format to KML coordinate format imagegps = exifgps.read(file) # print(imagegps) imagegps.process_exif() if imagegps._has_gps: print(file, imagegps._decimal_degrees) northing, easting = imagegps._decimal_degrees # order is latitude, longitude elevation = 0 # construct the KML tag and add it # TODO set the relative altitude mode... p = kml.Placemark(ns, file, file, file) # KML uses long, lat, alt for ordering coordinates (x, y, z) p.geometry = Point(easting, northing, elevation) d.append(p) # finish the KML print(k.to_string(prettyprint=True)) with open(kml_path, 'w') as f: f.write(k.to_string())
def generate_kml(meshviewer): k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns) k.append(d) for n in meshviewer['nodes']: if 'location' not in n: continue if 'latitude' not in n['location']: continue if 'longitude' not in n['location']: continue if 'hostname' not in n: continue if 'node_id' not in n: continue if 'is_online' not in n: continue extended = kml.ExtendedData() p = kml.Placemark(ns, n['node_id'], n['hostname']) p.geometry = Point(n['location']['longitude'], n['location']['latitude']) d.append(p) extended = [] if n['is_online']: status = "online" else: status = "offline" extended.append( kml.Data(value=status, name='status', display_name='Status')) url = 'https://vogtland.freifunk.net/map/#!/map/' + n['node_id'] extended.append(kml.Data(value=url, name='url', display_name='URL')) p.extended_data = kml.ExtendedData(elements=extended) return k
def getCurrentStateKml(serverUrl, rest=True): ''' Create the overall KML for the current state of the air quality. If we can't get fresh data, return None serverUrl = the url of the server providing this KML, so we can have the network link and the icons. ''' # Try to get data global CURRENT_DATA CURRENT_DATA = getData() global SERVER_URL SERVER_URL = serverUrl # Create the root KML object topKml = kml.KML() if rest: global ICON_PATH ICON_PATH = '/static/rest/basaltApp/icons/hvnp_air_quality' # Create a KML Document and add it to the KML root object document = kml.Document( NAME_SPACE, 'hvnp_caq_doc', "Hawai'i Volcanoes National Park", "Approximate direction of the volcanic gas plumes (wedges) from Halema'uma'u and Pu'u 'O'o. Colored circles show the current air quality conditions for sulfur dioxide and particulate matter at each monitoring site.", styles=buildStyles()) topKml.append(document) if not CURRENT_DATA: document.description = "NO DATA; Cannot reach server" return document.to_string(prettyprint=True) # Read and interpret the current conditions getConditions() # Build a top level KML folder topFolder = kml.Folder(NAME_SPACE, 'hvnp_caq_doc', 'Current Air Quality', getConditionsString()) # Build placemarks for all the found sites buildSites(topFolder) # Put the document together document.append(topFolder) # Return the KML as a string. return document.to_string(prettyprint=True)
def generate_kml(fname, poi_df): k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' styid = 'style1' # colors in KML: aabbggrr, aa=00 is fully transparent sty = styles.Style(id=styid, styles=[styles.LineStyle(color='9f0000ff', width=2)]) # transparent red doc = kml.Document(ns, '1', 'POIs', 'POIs visualization', styles=[sty]) k.append(doc) # Placemark for POIs for ix in poi_df.index: name = poi_df.loc[ix, 'poiName'] cat = poi_df.loc[ix, 'poiTheme'] lat = poi_df.loc[ix, 'poiLat'] lon = poi_df.loc[ix, 'poiLon'] url = poi_df.loc[ix, 'poiURL'] ext_data = kml.ExtendedData( ns, elements=[ kml.Data( name='video', value= "![CDATA[<iframe name='Framename' width='480' height='360' src='%s' frameborder='0'></iframe><br><br>]]" % (url)) ]) desc = ''.join([ 'POI Name: ', name, '<br/>Category: ', cat, '<br/>Coordinates: (%f, %f)' % (lat, lon), '<br/>URL: ', url ]) pm = kml.Placemark(ns, str(ix), name, desc, styleUrl='#' + styid, extended_data=ext_data) pm.geometry = Point(lon, lat) doc.append(pm) # save to file kmlstr = k.to_string(prettyprint=True) with open(fname, 'w') as f: f.write('<?xml version="1.0" encoding="UTF-8"?>\n') f.write(kmlstr)
def make_kml(polys, filename): k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns, 'docid', 'doc name', 'doc description') f = kml.Folder(ns, 'fid', 'f name', 'f description') k.append(d) d.append(f) nf = kml.Folder(ns, 'nested-fid', 'nested f name', 'nested f description') f.append(nf) f2 = kml.Folder(ns, 'id2', 'name2', 'description2') d.append(f2) for poly in polys: p = kml.Placemark(ns, 'id', 'name', 'description') p.geometry = poly f2.append(p) # print k.to_string(prettyprint=True) with open(filename, 'wb') as f: f.write(k.to_string())
def configure_document_root(self): root_document = fkml.Document(ns=self.NS, id='root-doc') self.register_schemas(root_document) self.kml_root = fkml.KML(ns=self.NS) self.kml_root.append(root_document) self.coord_container = fkml.Folder(ns=self.NS, id='coordinates', name='coordinates') self.coord_container.extended_data = fkml.SchemaData( ns=self.NS, schema_url=self.schema_set['document_metadata'], data=[{ 'name': 'gen_date', 'value': NOW.strftime(self.TS_OUTPUT_FMT) }, { 'name': 'spatial_reference', 'value': self.projection }]) root_document.append(self.coord_container)
def setup_gradient_and_t(self, steps): red = Color("blue") colors = list(red.range_to(Color("green"), steps)) styles = [] for idx, value in enumerate(colors): # DEBUG: print (f'VALUE: {value.hex_l}') style_id = "style-" idx_inc = idx + 1 style_id += str(idx_inc) lineStyle = LineStyle( ) #self.name_space,f'line-{idx_inc}',Color("white").hex_l) polyStyle = PolyStyle(self.name_space, f'poly-{idx_inc}', value.hex_l.replace('#', '#88')) this_style = kml.Style(self.name_space, style_id, (polyStyle, lineStyle)) styles.append(this_style) self.cell_document = kml.Document(self.name_space, 'mgrs-doc', 'Cells', 'MGRS cells matching query', styles) # try and limit returns # self.threshold = steps - 1 if steps > 1 else 1 self.threshold = 0 return styles
def kml_file_from_polygons(polygons, kml_file): if not isinstance(polygons, Iterable): polygons = [polygons] # Create the root KML object k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' # Create a KML Document and add it to the KML root object d = kml.Document(ns, 'docid', 'Zone unexplored tiles', 'Zone unexplored tiles') k.append(d) # Create a KML Folder and add it to the Document f = kml.Folder(ns) d.append(f) # Create a KML Folder and nest it in the first Folder nf = kml.Folder(ns) f.append(nf) # Create a second KML Folder within the Document f2 = kml.Folder(ns) d.append(f2) # ls = styles.LineStyle(ns, color='red', width=3) # s1 = styles.Style(styles=[ls]) # Create a Placemark with a simple polygon geometry and add it to the # second folder of the Document for polygon in polygons: # p = kml.Placemark(ns, styles=[s1]) p = kml.Placemark(ns) p.geometry = polygon f2.append(p) with open(kml_file, 'w') as myfile: myfile.write(k.to_string(prettyprint=True))
def kml_tiles(geometry, max_sq_geometry=None, individual: bool = False) -> str: ns = '{http://www.opengis.net/kml/2.2}' k = kml.KML(ns) style_normal = kml_styles.Style(id='normal', styles=[ kml_styles.LineStyle(color="400000ff", width=1), kml_styles.PolyStyle( color="300000ff", outline=(1 if individual else 0)), ]) style_max_sq = kml_styles.Style(id='max_sq', styles=[ kml_styles.LineStyle(color="40ff0000", width=1), kml_styles.PolyStyle( color="30ff0000", outline=(1 if individual else 0)), ]) d = kml.Document(ns, name="explorer tiles", styles=[style_normal, style_max_sq]) k.append(d) p = kml.Placemark(ns, styleUrl="#normal") p.geometry = geometry d.append(p) if max_sq_geometry: p = kml.Placemark(ns, styleUrl="#max_sq") p.geometry = max_sq_geometry d.append(p) return k.to_string(prettyprint=True)
def create_kml_for_placemark(placemark): # Create the root KML object kml_doc = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' data = placemark.extended_data.elements[0].data datadict = {} for kv in data: datadict[kv['name']] = kv['value'] nom_province = datadict['nom_province'] # Create a KML Document and add it to the KML root object d = kml.Document(ns, nom_province, nom_province, nom_province) kml_doc.append(d) # Create a Placemark with a simple polygon geometry and add it to the # second folder of the Document d.append(placemark) filepath = os.path.join(GEN_ZONES, 'BE-{}.kml'.format(nom_province)) with open(filepath, 'w', encoding='utf-8') as kml_handle: kml_handle.write(kml_doc.to_string(prettyprint=True)) return nom_province, filepath
def convert_to_kml(self): output_filename = self.flight_name + ".kml" k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' d = kml.Document(ns) k.append(d) f = kml.Folder(ns) d.append(f) i = 0 for row in self.geotags_list: row_num = [float(tag) for tag in row] row_num[0], row_num[1] = row_num[1], row_num[0] p = kml.Placemark(ns, str(i)) p.geometry = Point(row_num) f.append(p) i += 1 kml_file = open(output_filename, "w") kml_file.write(k.to_string(prettyprint=True)) kml_file.close()
def convert(infilename, outfilename='doc.kml', namecolumn=0): sf = shapefile.Reader(infilename) k = kml.KML() doc = kml.Document(name=infilename) k.append(doc) for sr in sf.shapeRecords(): if sr.shape.points: pm = kml.Placemark(name=unicode(sr.record[namecolumn]), description="test") if not hasattr(sr.shape, '__geo_interface__'): import ipdb ipdb.set_trace() pm.geometry = pygeoif.as_shape(sr.shape) doc.append(pm) if sr.shape.__geo_interface__ != pygeoif.as_shape( sr.shape).__geo_interface__: #import ipdb; ipdb.set_trace() print sr.record print len(sr.shape.__geo_interface__['coordinates']), len( pygeoif.as_shape( sr.shape).__geo_interface__['coordinates']) print sr.shape.__geo_interface__['type'], pygeoif.as_shape( sr.shape).__geo_interface__['type'] #for i in range(0,len(sr.shape.__geo_interface__['coordinates'])): # print sr.shape.__geo_interface__['coordinates'][i] == pygeoif.as_shape(sr.shape).__geo_interface__['coordinates'][i] xml = '<?xml version="1.0" encoding="UTF-8"?>' + k.to_string() #try: # xml = xml.decode('utf-8', 'ignore') #except: # pass #xml = xml.encode('utf-8') out = open(outfilename, 'w') out.write(xml) out.close()
def gen_kml(fname, traj_data, traj_stats, traj_id_list, traj_name_list=None): """Generate KML file""" assert (len(traj_id_list) > 0) if traj_name_list: assert (len(traj_id_list) == len(traj_name_list)) k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' stid = 'style1' # colors in KML: aabbggrr, aa=00 is fully transparent # developers.google.com/kml/documentation/kmlreference?hl=en#colorstyle st = styles.Style(id=stid, styles=[styles.LineStyle(color='2f0000ff', width=3)]) # transparent red doc = kml.Document(ns, '001', 'Trajectories', 'Trajectory visualization', styles=[st]) k.append(doc) stats = traj_stats[traj_stats['Trajectory_ID'].isin(traj_id_list)] assert (stats.shape[0] == len(traj_id_list)) pm_traj = [] pm_photo = [] for i in range(len(stats.index)): ri = stats.index[i] traj_id = stats.ix[ri]['Trajectory_ID'] photos = traj_data[traj_data['Trajectory_ID'] == traj_id] lngs = [lng for lng in photos['Longitude'].tolist()] lats = [lat for lat in photos['Latitude'].tolist()] name = 'Trajectory_' + str(traj_id) if traj_name_list: name += '_' + traj_name_list[i] desc = 'User_ID: ' + str(stats.ix[ri]['User_ID']) + \ '<br/>Start_Time: ' + str(stats.ix[ri]['Start_Time']) + \ '<br/>Travel_Distance: ' + str(round(stats.ix[ri]['Travel_Distance(km)'], 2)) + ' km' + \ '<br/>Total_Time: ' + str(round(stats.ix[ri]['Total_Time(min)'], 2)) + ' min' + \ '<br/>Average_Speed: ' + str(round(stats.ix[ri]['Average_Speed(km/h)'], 2)) + ' km/h' + \ '<br/>#Photos: ' + str(stats.ix[ri]['#Photo']) + \ '<br/>Photos: ' + str(photos['Photo_ID'].tolist()) pm = kml.Placemark(ns, str(traj_id), name, desc, styleUrl='#' + stid) pm.geometry = LineString([(lngs[j], lats[j]) for j in range(len(lngs))]) pm_traj.append(pm) for rj in photos.index: name = 'Photo_' + str(photos.ix[rj]['Photo_ID']) desc = 'Trajectory_ID: ' + str(traj_id) + \ '<br/>Photo_ID: ' + str(photos.ix[rj]['Photo_ID']) + \ '<br/>User_ID: ' + str(photos.ix[rj]['User_ID']) + \ '<br/>Timestamp: ' + str(photos.ix[rj]['Timestamp']) + \ '<br/>Coordinates: (' + str(photos.ix[rj]['Longitude']) + ', ' + str(photos.ix[rj]['Latitude']) + ')' + \ '<br/>Accuracy: ' + str(photos.ix[rj]['Accuracy']) + \ '<br/>URL: ' + str(photos.ix[rj]['URL']) pm = kml.Placemark(ns, str(photos.ix[rj]['Photo_ID']), name, desc) pm.geometry = Point(photos.ix[rj]['Longitude'], photos.ix[rj]['Latitude']) pm_photo.append(pm) for pm in pm_traj: doc.append(pm) for pm in pm_photo: doc.append(pm) kmlstr = k.to_string(prettyprint=True) with open(fname, 'w') as f: f.write('<?xml version="1.0" encoding="UTF-8"?>\n') f.write(kmlstr)