def buildStyles():
''' Build the various styles to be used for the placemarks'''
kmlStyles = []
for level in ADVISORY_SCALE:
# build the dot style
innerIconStyle = styles.IconStyle(NAME_SPACE,
scale=.7,
icon_href=buildDotIconUrl(level))
iconStyle = styles.Style(NAME_SPACE,
id=getDotIconId(level),
styles=[innerIconStyle])
kmlStyles.append(iconStyle)
# build the polygon style
innerPolyStyle = styles.PolyStyle(NAME_SPACE,
color='33' + ADVISORY_SCALE[level],
fill=1,
outline=1)
innerLineStyle = styles.LineStyle(NAME_SPACE,
color='FF' + ADVISORY_SCALE[level],
width=2)
polyStyle = styles.Style(NAME_SPACE,
id=getPolyStyleId(level),
styles=[innerLineStyle, innerPolyStyle])
kmlStyles.append(polyStyle)
return kmlStyles
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 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 gen_placemark_from_Line(coords, ns, names):
"""
create a placemark object for kml
:param coords: list of the base line and optionaly the offsets lines
:type coords: list of coordinates
:param ns: ns of kml version
:type ns: str
:param name: list of line names
:type name: list of str
:return: list of placemark object
:rtype: list of placemark
"""
outplacemarks = []
name_l = [name for name in names if 'offset_l' in name]
name_r = [name for name in names if 'offset_r' in name]
name_b = [
name for name in names
if 'offset_r' not in name and 'offset_l' not in name
]
coords_l = [
coords[names.index(name)] for name in names if 'offset_l' in name
]
coords_r = [
coords[names.index(name)] for name in names if 'offset_r' in name
]
dim = len(coords_r)
coords_b = [
coords[names.index(name)] for name in names
if 'offset_r' not in name and 'offset_l' not in name
]
colors = color_range_gen(dim + 1)
for i in range(dim):
ls = styles.LineStyle(ns=ns, id=None, color=colors[i + 1], width=1.5)
s1 = styles.Style(styles=[ls])
outplacemark_l = kml.Placemark(ns, None, name_l[i], None, styles=[s1])
outplacemark_r = kml.Placemark(ns, None, name_r[i], None, styles=[s1])
outplacemark_l.geometry = LineString(coords_l[i])
outplacemark_r.geometry = LineString(coords_r[i])
outplacemarks.append(outplacemark_l)
outplacemarks.append(outplacemark_r)
ls = styles.LineStyle(ns=ns, id=None, color=colors[0], width=3)
s1 = styles.Style(styles=[ls])
outplacemark = kml.Placemark(ns, None, name_b[0], None, styles=[s1])
outplacemark.geometry = LineString(coords_b[0])
outplacemarks.append(outplacemark)
return outplacemarks
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 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 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 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 trails(self, data):
#print(data)
self.description = ""
color = "ffffff00"
if 'name' in data:
name = data['name']
id = data['osm_id']
width = 3
if 'sac_scale' in data:
tmp = data['sac_scale']
index = tmp.split(';')
color = self.colors[self.default[index[0]]['color']]
# id = self.default[index]['id']
width = self.default[index[0]]['width']
#self.description += "<br>Sac_scale: " + data['sac_scale']
if 'mtb:scale:imba' in data:
self.description += "<br>Mnt Scale: " + str(data['mtb:scale:imba'])
if 'mtb:scale' in data:
pass
# self.description += "<br>Mnt Scale: " + str(data['mtb:scale'])
# Create the description pop-up
if 'surface' in data:
self.description += "<br>Surface: " + data['surface']
if 'bicycle' in data:
self.description += "<br>Bicycle: " + data['bicycle']
if 'horse' in data:
self.description += "<br>Horse: " + data['horse']
if 'atv' in data:
self.description += "<br>Atv: " + data['atv']
if 'access' in data:
self.description += "<br>Access: " + data['access']
if 'tracktype' in data:
self.description += "<br>Tracetype: " + data['tracktype']
if 'trail_visibility' in data:
self.description += "<br>Visability: " + data['trail_visibility']
if 'motor_vehicle' in data:
self.description += "<br>Motor Vehicle: " + data['motor_vehicle']
lstyle = styles.LineStyle(color=color, width=width)
self.styles = styles.Style(styles=[lstyle])
#print(self.description)
return self.styles, self.description
def main(argv):
# Get command line options
try:
opts, args = getopt.getopt(argv, "hf:o:a:",
["filepath=", "long-start=", "lat-start="])
except getopt.GetoptError:
print 'create-haworth-cemetery-f-kml.py -f <filepath> -o <long start> -a <lat start>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'create-haworth-cemetery-f-kml.py -f <filepath> -o <long start> -a <lat start>'
sys.exit()
elif opt in ("-f", "--filepath"):
filepath = arg
elif opt in ("-o", "--long-start"):
long_start = float(arg)
elif opt in ("-a", "--lat-start"):
lat_start = float(arg)
map_origin = Point(long_start, lat_start)
# Read in all the graves as objects and stick them in a grid.
graveyard = [[None for i in range(GRAVEYARD_MAX_SIZE)]
for j in range(GRAVEYARD_MAX_SIZE)]
with open(filepath) as csvfile:
reader = csv.DictReader(csvfile)
for r in reader:
if r['column']:
row = int(r['row'])
column = int(r['column'])
graveyard[row][column] = Grave(r['section'], r['grave_id'],
row, column, r['inscription'])
# Create the root KML object.
k = kml.KML()
# Create the KML Document styles to use.
doc_styles = []
a = []
a.append(styles.LineStyle(NS, None, 'ffbdbdbd'))
a.append(styles.PolyStyle(NS, None, '4dbdbdbd'))
doc_styles.append(kml.Style(NS, 'poly-BDBDBD-1-77-normal', a))
a[0] = styles.LineStyle(NS, None, 'ffbdbdbd', None, 2)
doc_styles.append(kml.Style(NS, 'poly-BDBDBD-1-77-highlight', a))
doc_styles.append(
kml.StyleMap(NS, "poly-BDBDBD-1-77",
kml.StyleUrl(NS, None, '#poly-BDBDBD-1-77-normal'),
kml.StyleUrl(NS, None, '#poly-BDBDBD-1-77-highlight')))
# Create the KML Document, and add it to the KML root object.
d = kml.Document(NS, None, NAME, DESCRIPTION.format(SECTION), doc_styles)
k.append(d)
# Create a KML Folder for the section and add it to the Document.
f = kml.Folder(NS, None, "Section {}".format(SECTION))
k.append(f)
# Process the graveyard grid, creating a Placemark with a polygon for each grave.
for i in range(GRAVEYARD_MAX_SIZE):
for j in range(GRAVEYARD_MAX_SIZE):
if graveyard[i][j]:
g = graveyard[i][j]
name = '{}-{}'.format(g.section, g.grave_id)
p = kml.Placemark(NS, None, name.lower(), g.inscription, None,
'#poly-BDBDBD-1-77')
lon = long_start + (i * (LONG_2FEET * 3))
lat = lat_start + (j * (LAT_2FEET * 2))
p.geometry = Polygon([
(lon, lat, 0), (lon + LONG_3FEET + LONG_2FEET, lat, 0),
(lon + LONG_3FEET + LONG_2FEET, lat + LAT_3FEET, 0),
(lon, lat + LAT_3FEET, 0), (lon, lat, 0)
])
p.geometry = shapely.affinity.rotate(p.geometry,
ADJUSTMENT_ANGLE,
map_origin)
f.append(p)
# Print out the KML Object as a string.
print k.to_string(prettyprint=True)
heading=float(nmea[54:59])
speed_kt=float(nmea[47:53])
speed_kmh=speed_kt*1.852
if speed_kmh > kmh_max:
kmh_max = speed_kmh
if speed_kmh < kmh_min:
kmh_min = speed_kmh
if lonlat_prev:
dist_m = distance(lonlat_prev[1], lonlat_prev[0], lonlat[1], lonlat[0])
travel += dist_m
if dist_m < discontinuety_m: # don't draw too long lines
# if no IRI20 available, take IRI100 for color and name
iri_avg_main = iri_avg
if iri20_avg > 0:
iri_avg_main = iri20_avg
ls0 = styles.LineStyle(ns,
color=("%08X" % color32(iri_avg_main/red_iri)), width=6)
lsty0 = styles.Style(styles = [ls0])
p1 = kml.Placemark(ns, 'id',
name=("%.2f" % iri_avg_main),
description=(
("L100=%.2f mm/m\n"
"R100=%.2f mm/m\n"
"L20=%.2f, R20=%.2f\n"
"Lc=%.2f, Rc=%.2f\n"
"azl0=%.3e, azr0=%.3e\n"
"slope_l=%.3e, slope_r=%.3e\n"
"phi=%.1f, theta=%.1f, psi=%.1f\n"
"v=%.1f km/h\n%s"
) %
(iri_left, iri_right,
iri20_left, iri20_right,
def write_kml_tiles(out_filepath,
tiles,
land_mask_filepath,
doc_name="doc name",
doc_desc="doc description"):
k = kml.KML()
ns = '{http://www.opengis.net/kml/2.2}'
d = kml.Document(ns, 'docid', doc_name, doc_desc)
k.append(d)
p_style = styles.PolyStyle(ns, 'id', fill=0)
l_style = styles.LineStyle(ns, 'id', color="FF0000FF")
sty = kml.Style(ns, 'id', styles=[p_style, l_style])
# read SHP land mask
driver = ogr.GetDriverByName("ESRI Shapefile")
ds_mask = driver.Open(land_mask_filepath, update=False)
layer_mask = ds_mask.GetLayer()
for tile_counter in range(0, tiles.shape[2]):
points = tiles[:, :, tile_counter]
points = np.concatenate((points, np.array([points[0, :]])), axis=0)
polygon_points = []
for point in points:
polygon_points.append((float(point[0]), float(point[1])))
f = kml.Folder(ns, 'fid', 'f name', 'f description')
d.append(f)
# define geometry
geom = geometry.Geometry()
geom.geometry = Polygon(polygon_points)
# create and add metadata
polygon = ogr.CreateGeometryFromWkt(geom.geometry.wkt)
coversland = False
for feat_mask in layer_mask:
if polygon.Intersects(feat_mask.geometry()):
coversland = True
break
layer_mask.ResetReading()
ll_lon = int(np.min(points[:, 0]))
ll_lat = int(np.min(points[:, 1]))
extent = int(np.max(points[:, 0]) - np.min(points[:, 0]))
tilename = "{:03d}_{:03d}".format(
int(np.min(points[:, 0])) + 180,
int(np.min(points[:, 1])) + 90)
schema_data = kml.SchemaData(
ns,
schema_url="#" +
os.path.splitext(os.path.basename(out_filepath))[0])
schema_data.append_data(name="GRID", value="LatLon Grid")
schema_data.append_data(name="VERSION", value="V1")
schema_data.append_data(name="ZONE", value="Globe")
schema_data.append_data(name="SHORTNAME", value="LLG GL")
schema_data.append_data(name="TILE", value=tilename)
schema_data.append_data(name="EXTENT", value=str(extent))
schema_data.append_data(name="LLLON", value=str(ll_lon))
schema_data.append_data(name="LLLAT", value=str(ll_lat))
schema_data.append_data(name="COVERSLAND", value=str(int(coversland)))
# create placemark
p = kml.Placemark(ns,
'id',
extended_data=kml.ExtendedData(
ns, elements=[schema_data]))
p.geometry = geom
p.append_style(sty)
f.append(p)
with open(out_filepath, 'w') as filehandle:
filehandle.write(k.to_string(prettyprint=True))
def roads(self, data):
"""
trunk - Wide Red/Orange, "salmon1"
motorway - Wide pink, "lightpink3"
primary - Wide light orange, "burlywood1"
tertiary - Wide white, "white"
secondary - Wide Yellow, "yellow"
unclassified - white, "white"
residential - white, "white"
track - dotted brown, "brick"
path - dotted red, "red"
service - white, "white"
footway - dotted red, "red"
road - gray, "gray"
"""
index = data['highway']
#logging.debug("Looking for road type: %r" % index)
width = 3.0
try:
id = self.default[index]['id']
width = self.default[index]['width']
color = self.colors[self.default[diff]['color']]
except:
color = 'pink'
self.description = ""
# Tags that go in the description popyup
if 'service' in data:
if data['service'] == 'driveway':
color = self.colors[self.default['driveway']['color']]
self.description += "Private Driveway"
else:
if 'name' in data:
self.description += "<br>Name: " + data['name']
if 'alt_name' in data:
self.description += "<br>Alt Name: " + data['alt_name']
if 'tracktype' in data:
if data['tracktype'] == 'yes':
color = self.colors[self.default['tracktype']['color']]
self.description += "<br>Tracktype: " + data['tracktype']
if 'motor_vehicle' in data:
if data['motor_vehicle'] == 'yes':
color = self.colors[self.default['motor_vehicle']['color']]
self.description += "<br>Vehicles OK: yes"
if 'access' in data:
if data['access'] == 'private':
color = self.colors[self.default['private']['color']]
if 'atv' in data:
if data['atv'] == 'yes':
color = self.colors[self.default['atv']['color']]
self.description += "<br>ATVs OK: yes"
if 'horse' in data:
if data['horse'] == 'yes':
color = self.colors[self.default['horse']['color']]
self.description += "<br>Horse OK: yes"
if 'bicycle' in data:
if data['bicycle'] == 'yes':
color = self.colors[self.default['bicycle']['color']]
self.description += "<br>Bicycle OK: yes"
if '4wd_only' in data:
if data['4wd_only'] == 'yes':
color = self.colors[self.default['4wd_only']['color']]
self.description += "<br>4wd Only: " + data['4wd_only']
if 'smoothness' in data:
pass
if 'surface' in data:
pass
self.description += "<p>Data: %r" % data
lstyle = styles.LineStyle(color=color, width=width)
self.styles = styles.Style(styles=[lstyle])
#print(self.description)
return self.styles, self.description
def main(argv):
# Get command line options
try:
opts, args = getopt.getopt(argv, "ho:a:",
["long-start=", "lat-start="])
except getopt.GetoptError:
print 'test-rotation-kml.py -o <long start> -a <lat start>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'test-rotation-kml.py -o <long start> -a <lat start>'
sys.exit()
elif opt in ("-o", "--long-start"):
long_start = float(arg)
elif opt in ("-a", "--lat-start"):
lat_start = float(arg)
map_origin = Point(long_start, lat_start)
k = kml.KML()
# Create the KML Document styles to use.
doc_styles = []
a = []
a.append(styles.LineStyle(NS, None, 'ffbdbdbd'))
a.append(styles.PolyStyle(NS, None, '4dbdbdbd'))
doc_styles.append(kml.Style(NS, 'poly-BDBDBD-1-77-normal', a))
a[0] = styles.LineStyle(NS, None, 'ffbdbdbd', None, 2)
doc_styles.append(kml.Style(NS, 'poly-BDBDBD-1-77-highlight', a))
doc_styles.append(
kml.StyleMap(NS, "poly-BDBDBD-1-77",
kml.StyleUrl(NS, None, '#poly-BDBDBD-1-77-normal'),
kml.StyleUrl(NS, None, '#poly-BDBDBD-1-77-highlight')))
# Create the KML Document, and add it to the KML root object.
d = kml.Document(NS, None, NAME, DESCRIPTION.format(SECTION), doc_styles)
k.append(d)
# Create a KML Folder for the section and add it to the Document.
f = kml.Folder(NS, None, "Section {}".format(SECTION))
k.append(f)
# Process a spiral of markers in a counter-clockwise direction
lon = long_start + (OBJECT_START_ROW * (LONG_2FEET * 3))
lat = lat_start + (OBJECT_START_COL * (LAT_2FEET * 2))
adjustment_angle = 0.00
while adjustment_angle < 360:
name = 'Degrees: {}'.format(adjustment_angle)
p = kml.Placemark(NS, None, name, "Test Rotation", None,
'#poly-BDBDBD-1-77')
p.geometry = Polygon([(lon, lat, 0),
(lon + LONG_3FEET + LONG_2FEET, lat, 0),
(lon + LONG_3FEET + LONG_2FEET, lat + LAT_3FEET,
0), (lon, lat + LAT_3FEET, 0), (lon, lat, 0)])
p.geometry = shapely.affinity.rotate(p.geometry, adjustment_angle,
map_origin)
f.append(p)
adjustment_angle += ADJUSTMENT_ANGLE_INCR
# Print out the KML Object as a string.
print k.to_string(prettyprint=True)
f = kml.Folder(ns, 'Antennas_' + dpa_id, 'Antennas',
'Antenna Angles')
placementDoc.append(f)
feature1[feature_index].append(f)
for c in newcover:
center = c[0]
index = c[1]
angle = c[2]
print "==== center index angle ====", center, index, angle
lon, lat = basemap(center[0], center[1], inverse=True)
lobe = antennacover.translate_and_rotate(
antenna_cover_patterns, center, index, angle)
# Note that our frame of reference is Due EAST but the conventional
# way of specifying angles is due north.
angle_degrees = (angle / math.pi * 180 - 90) % 360
lstyle = styles.LineStyle(color='ff0055ff', width=2.0)
style = styles.Style(styles=[lstyle])
p = kml.Placemark(
ns,
"antenna" + str(lobe_counter),
'antenna',
'Sensitivity (dBm): ' +
str(antenna_cover_patterns[index].sensitivity_dbm) +
", Aperture angle: " + str(aperture_angle) + " degrees" +
", lon : " + str(lon) + " lat : " + str(lat) +
", Azimuth angle: " +
str(float(np.round(angle_degrees, 2))),
styles=[style])
p.geometry = projection.polygon_to_latlon(lobe)
# p.styles.StyleUrl(url='http://maps.google.com/mapfiles/kml/shapes/placemark_square.png')
# p.styles.IconStyle(color='#ff5500', scale=2)
def __init__(self, ns):
self.ns = ns
self.description = ""
self.default = dict()
self.icons = list()
self.colors = dict()
self.colors['pink'] = 'ffff00ff'
self.colors['red'] = 'ff0000ff'
self.colors['gray'] = 'ff808080'
self.colors['black'] = 'ff000000'
self.colors['orange'] = 'ff00a5ff'
self.colors['yellow'] = 'ffffff00'
self.colors['magenta'] = 'ffff00ff'
self.colors['maroon'] = 'ff800000'
self.colors['purple'] = 'ff800080'
self.colors['cyan'] = 'ff00ffff'
self.colors['lightblue'] = 'ff00ffff'
self.colors['blue'] = 'ffff0000'
self.colors['darkblue'] = 'ff000080'
self.colors['teal'] = 'ff008080'
self.colors['olive'] = 'ff808000'
self.colors['lightgreen'] = 'ff00ff00'
self.colors['green'] = 'ff008000'
self.colors['darkgreen'] = 'ff008000'
self.colors['brown'] = 'ff008000' # FIXME: wrong value!
# Access
width = 3.0
self.default['private'] = {"color": "gray", "width": width}
# highway=path
self.default['hiking'] = {"color": "brown", "width": width}
self.default['mountain_hiking'] = {"color": "orange", "width": width}
self.default['demanding_mountain_hiking'] = {
"color": "purple",
"width": width
}
self.default['alpine_hiking'] = {"color": "lightblue", "width": width}
self.default['demanding_alpine_hiking'] = {
"color": "lightblue",
"width": width
}
self.default['difficult_alpine_hiking'] = {
"color": "lightblue",
"width": width
}
self.default['0'] = {"color": "brown", "width": width}
self.default['1'] = {"color": "green", "width": width}
self.default['2'] = {"color": "blue", "width": width}
self.default['3'] = {"color": "red", "width": width}
self.default['4'] = {"color": "black", "width": width}
# Tracktype
self.default['grade1'] = {
"color": "brown",
"id": "BrownLine",
"width": 2.0
}
self.default['grade2'] = {
"color": "green",
"id": "BrownLine",
"width": 2.0
}
self.default['grade3'] = {
"color": "blue",
"id": "BrownLine",
"width": 2.0
}
self.default['grade4'] = {
"color": "red",
"id": "BrownLine",
"width": 2.0
}
# highway=*
self.default['trunk'] = {
"color": "orange",
"id": "Wide Red/Orange",
"width": 3.0
}
self.default['motorway'] = {
"color": "lightpink3",
"id": "WideLightPink",
"width": 3.0
}
self.default['primary'] = {
"color": "burlywood1",
"id": "WideLightOrange",
"width": 3.0
}
self.default['tertiary'] = {
"color": "white",
"id": "WideWhite",
"width": 3.0
}
self.default['secondary'] = {
"color": "yellow",
"id": "WideYellow",
"width": 3.0
}
# Space cadets... fix later when possible
self.default['road'] = {"color": "black", "id": "gray", "width": 3.0}
self.default['service'] = {
"color": "red",
"id": "RedLine",
"width": 3.0
}
self.default['motorway_link'] = {
"color": "red",
"id": "RedLine",
"width": 3.0
}
self.default['secondary_link'] = {
"color": "yellow",
"id": "YellowLine",
"width": 3.0
}
self.default['trunk_link'] = {
"color": "salmon1",
"id": "OrangeLine",
"width": 3.0
}
self.default['living_street'] = {
"color": "white",
"id": "whiteLine",
"width": 3.0
}
# Probably added by me
self.default['unclassified'] = {
"color": "white",
"id": "whiteLine",
"width": 3.0
}
self.default['residential'] = {
"color": "white",
"id": "whiteLine",
"width": 3.0
}
self.default['track'] = {
"color": "brown",
"id": "DottedBrown",
"width": 3.0
}
self.default['4wd_only'] = {
"color": "black",
"id": "dotted brown",
"width": 3.0
}
# handled by self.trails
#self.default['path']= { "color": "black", "id": "dotted red", "width": 3.0}
self.default['driveway'] = {
"color": "white",
"id": "whiteLine",
"width": 3.0
}
# a footway is a sidewalk, so we don't care
#self.default['footway'] = { "color": "black", "id": "dotted red", "width": 3.0}
self.default['cycleway'] = {
"color": "black",
"id": "dotted red",
"width": 3.0
}
self.default['bridleway'] = {
"color": "black",
"id": "dotted red",
"width": 3.0
}
# Ignore surface tag for now
#self.default['dirt'] = { "color": "black", "id": "dotted red", "width": 3.0}
# Ignore tracktype tag for now
#self.default['grade1'] = { "color": "black", "id": "dotted red", "width": 3.0}
# For smoothness tag
self.default['impassable'] = {
"color": "blue",
"id": "blue",
"width": 3.0
}
self.default['poor'] = {"color": "blue", "id": "blue", "width": 3.0}
self.default['bad'] = {"color": "blue", "id": "blue", "width": 3.0}
self.default['horrible'] = {
"color": "blue",
"id": "blue",
"width": 3.0
}
self.default['very_horrible'] = {
"color": "blue",
"id": "blue",
"width": 3.0
}
#
self.default['motor_vehicle'] = {
"color": "blue",
"id": "blue",
"width": 1.0
}
self.default['horse'] = {"color": "blue", "id": "blue", "width": 1.0}
self.default['atv'] = {"color": "blue", "id": "blue", "width": 1.0}
self.default['bicycle'] = {"color": "blue", "id": "blue", "width": 1.0}
# Piste trail grooming
# self.default['backcountry'] = { "color": "yellow", "id": "yellow", "width": 1.0}
# self.default['nordic'] = { "color": "blue", "id": "blue", "width": 1.0}
# self.default['downhill'] = { "color": "blue", "id": "blue", "width": 1.0}
self.default['skitour'] = {"color": "blue", "id": "blue", "width": 1.0}
self.default['snow_park'] = {
"color": "blue",
"id": "blue",
"width": 1.0
}
self.default['snowshoe'] = {
"color": "blue",
"id": "blue",
"width": 1.0
}
self.default['skating'] = {"color": "blue", "id": "blue", "width": 1.0}
self.default['classic'] = {"color": "blue", "id": "blue", "width": 1.0}
self.linestyles = list()
for key, val in self.default.items():
# lstyle = styles.LineStyle(id=val['id'], color=val['color'], width=val['width'])
lstyle = styles.LineStyle(color=val['color'], width=val['width'])
self.linestyles.append(styles.Style(styles=[lstyle]))
self.styles = list()
self.description = ""
def piste(self, data):
self.description = ""
color = "ffffff00"
if 'piste:name' in data:
name = data['piste:name']
if 'name' in data:
name = data['name']
if 'piste:name' in data:
self.description += data['piste:name']
id = data['osm_id']
width = 3
# Colors based on https://wiki.openstreetmap.org/wiki/Piste_Maps
# Downhill Piste difficulty
downhill = dict()
width = 2.0
downhill['easy'] = {"color": "lightgreen", "width": width}
downhill['novice'] = {"color": "lightgreen", "width": width}
downhill['intermediate'] = {"color": "blue", "width": width}
downhill['extreme'] = {"color": "orange", "width": width}
downhill['freeride'] = {"color": "yellow", "width": width}
downhill['expert'] = {"color": "gray", "width": width}
downhill['advanced'] = {"color": "gray", "width": width}
downhill['unknown'] = {"color": "gray", "width": width}
downhill['Traverse'] = {"color": "gray", "width": width}
nordic = dict()
width = 1.0
nordic['easy'] = {"color": "cyan", "width": width}
nordic['novice'] = {"color": "cyan", "width": width}
nordic['intermediate'] = {"color": "blue", "width": width}
nordic['expert'] = {"color": "gray", "width": width}
nordic['advanced'] = {"color": "gray", "width": width}
nordic['skating'] = {"color": "yellow", "width": width}
nordic['classic'] = {"color": "green", "width": width}
nordic['classic+skating'] = {"color": "green", "width": width}
nordic['unknown'] = {"color": "black", "width": width}
if 'piste:type' not in data:
data['piste:type'] = 'downhill'
if 'piste:difficulty' not in data:
# When in doubt, make it bad
diff = 'unknown'
data['piste:difficulty'] = 'unknown'
else:
diff = data['piste:difficulty']
if 'piste:type' in data:
self.description += "<br>Type: " + data['piste:type']
if data['piste:type'] == 'downhill':
color = self.colors[downhill[diff]['color']]
# id = downhill[diff]['osm_id']
width = downhill[diff]['width']
elif data['piste:type'] == 'nordic':
diff = data['piste:difficulty']
color = self.colors[nordic[diff]['color']]
# id = nordic[diff]['osm_id']
width = nordic[diff]['width']
# FIXME: improve these colors
else:
logging.warning("Unsupported piste type, %r" %
data['piste:type'])
color = self.colors['maroon']
width = 1.0
else:
color = self.colors['purple']
# Create the description pop-up
if 'piste:difficulty' in data:
self.description += "<br>Difficulty: " + data['piste:difficulty']
else:
data['piste:difficulty'] = 'extreme'
if 'piste:grooming' in data:
self.description += "<br>Grooming: " + data['piste:grooming']
lstyle = styles.LineStyle(color=color, width=width)
self.styles = styles.Style(styles=[lstyle])
#print(self.description)
return self.styles, self.description
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)
def ConvertAthenaCsvToKml(outputBucket, outputKey, inputBucket, inputKey):
print(outputBucket)
print(outputKey)
print(inputBucket)
print(inputKey)
# Get the object from the event and show its content type
k = kml.KML()
ns = '{http://www.opengis.net/kml/2.2}'
lstyle = styles.LineStyle(color='7dff0000', width=2.0, id='redLine')
style = styles.Style(styles=[lstyle])
d = kml.Document(ns, 'docid', 'doc name', 'doc description', [style])
k.append(d)
shapeFolder = kml.Folder(ns, 'fid', 'f name', 'f description')
d.append(shapeFolder)
bucket = inputBucket
key = inputKey
try:
response = s3.get_object(Bucket=bucket, Key=key)
csvRows = response['Body'].read().decode('utf-8').splitlines()
rowIterator = iter(csvRows)
next(rowIterator)
for row in rowIterator:
csvColumns = row.split(',', 1)
icao24 = csvColumns[0].strip('"')
pathString = csvColumns[1]
pathString = pathString.strip('""[]')
pathArray = pathString.split('"", ""')
tupleArray = [tuple(map(float, x.split(','))) for x in pathArray]
tupleArray = [(pos[1], pos[0], pos[2] * .3048)
for pos in tupleArray]
if len(tupleArray) > 1:
placemark = kml.Placemark(ns, icao24, icao24,
'Flight path for ' + icao24)
lineGeo = LineString(coordinates=tupleArray)
placemark.geometry = geometry.Geometry(
geometry=lineGeo, altitude_mode='absolute')
placemark.styleUrl = "#redLine"
shapeFolder.append(placemark)
s3.put_object(Body=k.to_string(),
ContentType='application/vnd.google-earth.kml+xml',
Bucket=outputBucket,
Key="AUSAirTraffic-" +
time.strftime('%l:%M%p %Z on %b %d, %Y') + ".kml")
#print(k.to_string(prettyprint=True))
return
except Exception as e:
print(e)
raise e
