def setUp(self):
self.kml = KML.kml(
KML.Document(
KML.Folder(
KML.name("Folder0"),
KML.Placemark(
KML.name("Placemark0"),
KML.Point(KML.coordinates("0,0,0")),
KML.altitudeMode("relativeToGround"),
KML.styleUrl("#style_test"),
KML.description("Description: test placemark 0"),
KML.ExtendedData(
KML.SchemaData(
KML.SimpleData("TEST0").set("name",
"test0"), ), ),
),
KML.Placemark(
KML.name("Placemark1"),
KML.Point(KML.coordinates("0,0,0")),
KML.altitudeMode("relativeToGround"),
KML.styleUrl("#style_test"),
KML.description("Description: test placemark 1"),
KML.ExtendedData(
KML.SchemaData(
KML.SimpleData("TEST1").set("name",
"test1"), ), ),
)),
KML.Folder(
KML.name("Folder1"),
KML.Placemark(
KML.name("Placemark0"),
KML.Point(KML.coordinates("0,0,0")),
KML.altitudeMode("relativeToGround"),
KML.styleUrl("#style_test"),
KML.description("Description: test placemark 0"),
KML.ExtendedData(
KML.SchemaData(
KML.SimpleData("TEST0").set("name",
"test0"), ), ),
),
KML.Placemark(
KML.name("Placemark1"),
KML.Point(KML.coordinates("0,0,0")),
KML.altitudeMode("relativeToGround"),
KML.styleUrl("#style_test"),
KML.description("Description: test placemark 1"),
KML.ExtendedData(
KML.SchemaData(
KML.SimpleData("TEST1").set("name",
"test1"), ), ),
))))
kmldata.save_kml(self.kml, "Default.kml")
def extend(infos, expocode):
extended = KML.ExtendedData(
KML.Data(
KML.value(expocode),
name='expocode',
), *infos)
return extended
def setUp(self):
self.placemark = KML.Placemark(
KML.name("Test Placemark"),
KML.Point(KML.coordinates("0,0,0")),
KML.altitudeMode("relativeToGround"),
KML.styleUrl("#style_test"),
KML.description("Description: test placemark"),
KML.ExtendedData(
KML.SchemaData(KML.SimpleData("TEST").set("name",
"test"), ), ),
)
def create_placemark_element(lat, lon, row, col, val, icon_file, inps):
"""Create an KMZ Placemark element.
Parameters: lat/lon - float, latitude / longitude in degrees
row/col - int, row / column number
val - float, value
icon_file - str, path of the icon file
inps - Namespace object
Returns: placemark - KMZ.Placemark() object
"""
placemark = KML.Placemark(
# style
KML.Style(
KML.IconStyle(
KML.color(get_hex_color(val, inps.colormap, inps.norm)),
KML.scale(0.5),
KML.Icon(KML.href(icon_file),
),
),
),
# extended data
KML.ExtendedData(
KML.Data(
KML.value(f"{lat:.6f}˚"),
name="Latitude",
),
KML.Data(
KML.value(f"{lon:.6f}˚"),
name="Longitude",
),
KML.Data(
KML.value(f"{row:.0f}"),
name="Row",
),
KML.Data(
KML.value(f"{col:.0f}"),
name="Column",
),
KML.Data(
KML.value(f"{val:.2f} {inps.disp_unit}"),
name="Value",
),
),
# point coord
KML.Point(
KML.coordinates(f"{lon},{lat}"),
),
)
return placemark
def photo2kml(files):
tag_inds = [tag_dict[t] for t in meta_tags]
metadata, inc = exiftool(files, tag_inds)
# sorded by datetime
metadata = sorted(metadata, key=lambda l: l[3])
ndata = len(metadata)
if not inc:
sys.exit('Error: File not found.')
elif not ndata:
sys.exit('Error: GPSInfo not found in file.')
kml_doc = KML.kml(
KML.Document(
KML.name(trip_name),
KML.Style(
KML.IconStyle(
KML.color(color_argb), # only valid in Google Earth
KML.scale(1.), # only valid in Google Earth
KML.Icon(KML.href(icon_url)),
KML.hotSpot(x='0.5',
y='0.0',
xunits="fraction",
yunits="fraction")),
id='icon_style',
)))
# append location one by one
for meta in metadata:
msg = 'Photo location.'
#msg += '\nTrip: %s' % trip_name
#msg += '\nTime: %s' % meta[3]
#msg += '\nModel: %s' % meta[4]
#msg += '\nName: %s' % meta[0]
kml_doc.Document.append(
KML.Placemark(
# use datetime as marker name
KML.name(meta[3]),
KML.styleUrl('#%s' % 'icon_style'),
KML.description(msg),
KML.Point(KML.coordinates('%f, %f' % (meta[1], meta[2]))),
# ExtendedData only valid in Google Map
KML.ExtendedData(
KML.Data(KML.value(trip_name), name='Trip'),
KML.Data(KML.value(meta[3]), name='Time'),
KML.Data(KML.value(meta[4]), name='Model'),
KML.Data(KML.value(meta[0].replace('./', '')),
name='Name'),
)))
return kml_doc, ndata
def generateKMZs(self, dirs, outputDir):
for index, directory in enumerate(dirs):
geotaggedDir = os.path.join(directory, "Geotagged-Images")
dirName = os.path.basename(directory)
QgsMessageLog.logMessage(dirName, "dirs", 0)
imgToGPS = self.constructImgMap(geotaggedDir, dirName)
if imgToGPS is None:
return
root = KML.kml(
KML.Document(
KML.name(dirName),
KML.Style(KML.IconStyle(
KML.Icon(
KML.href(
"http://maps.google.com/mapfiles/kml/pushpin/wht-pushpin.png"
)), KML.colorMode("normal"), KML.scale(0.6)),
id="scale")))
for imgName in imgToGPS:
lon, lat, alt = imgToGPS[imgName]
if lat and lon and alt:
placemark = KML.Placemark(
KML.visibility(0),
KML.description("{}, {}m".format(imgName, alt)),
KML.styleUrl("#scale"),
KML.Point(
KML.coordinates("{}, {}, {}".format(lon, lat,
alt))),
KML.ExtendedData(
KML.Data(KML.value(imgName), name='imgName'),
KML.Data(KML.value(geotaggedDir), name='imgDir'),
KML.Data(KML.value(dirName), name='folderName'),
KML.Data(KML.value(lat), name='Latitude'),
KML.Data(KML.value(lon), name='Longitude'),
KML.Data(KML.value(alt), name='Altitude')))
root.Document.append(placemark)
else:
reply = QMessageBox.question(
self.iface.mainWindow(), 'Continue?',
'Warning: {} in {} cannot be found. Still continue?'.
format(imgName,
dirName), QMessageBox.Yes, QMessageBox.No)
if (reply == QMessageBox.No):
return
outputPath = os.path.join(outputDir, dirName + ".kmz")
kml_str = '<?xml version="1.0" encoding="UTF-8"?>\n'
kml_str += etree.tostring(root, pretty_print=True).decode('UTF-8')
with ZipFile(outputPath, 'w') as zip:
zip.writestr('doc.kml', kml_str)
def export_data(self, dataset):
"""
Returns format representation for given dataset.
"""
kml_doc = KML.Document(KML.name('PCA Locations'))
for pca_data in dataset.dict:
locations = GwPCALocation.objects.filter(pca__id=pca_data['ID'])
for loc in locations:
data_copy = pca_data.copy()
data_copy['Locality'] = loc.locality.name
data_copy['CAD_CODE'] = loc.locality.cad_code
data_copy['CAS_CODE'] = loc.locality.cas_code
data_copy['Gateway'] = loc.gateway.name
data_copy['Location Name'] = loc.location.name
data = KML.ExtendedData()
for key, value in data_copy.items():
data.append(KML.Data(KML.value(value), name=key))
point = KML.Placemark(
KML.name(data_copy['Number']),
data,
KML.Point(
KML.coordinates('{long},{lat}'.format(
lat=loc.location.point.y,
long=loc.location.point.x)), ),
)
kml_doc.append(point)
return etree.tostring(etree.ElementTree(KML.kml(kml_doc)),
pretty_print=True)
def ConvertShapeToPlacemark(shape, geoid, aland, awater, kml):
#if len(shape.parts) > 1:
# print '----------geoid=%s aland=%s awater=%s' % (geoid, aland, awater)
if shape.shapeType != 5:
raise Exception('Unexpected shape type [%d] in file' % shape.shapeType)
pm = KML.Placemark(
KML.name('%s' % geoid),
KML.styleUrl('#ts'),
KML.ExtendedData(
KML.Data(
KML.displayName('ALAND'),
KML.value(aland),
name='string'
),
KML.Data(
KML.displayName('AWATER'),
KML.value(awater),
name='string'
)
),
KML.MultiGeometry(
KML.Polygon(
KML.extrude(0),
KML.altitudeMode('clampToGround')
)
)
)
# The parentPoly will be used to append rings, and a
# new Polygon will be appended for multiple rings in
# a geography.
parentPoly = pm.MultiGeometry.Polygon
#if len(shape.parts) > 1:
# print 'shape has %d parts' % len(shape.parts)
for i in range(0, len(shape.parts)):
lo = shape.parts[i]
hi = len(shape.points)
if i < len(shape.parts) - 1:
hi = shape.parts[i + 1]
#if len(shape.parts) > 1:
# print 'shape has points in [%d, %d) of %d' % (lo, hi, len(shape.points))
if (shape.points[lo][0] != shape.points[hi-1][0] or
shape.points[lo][1] != shape.points[hi-1][1]):
raise Exception('Loop endpoints in [%d, %d) do not match' % (lo, hi))
coords = []
for j in reversed(range(lo, hi)):
lng = shape.points[j][0]
lat = shape.points[j][1]
coords.append([lng, lat])
latlngCoords = []
for c in coords:
latlngCoords.append('%f,%f,0' % (c[0], c[1]))
coordinates = ' '.join(latlngCoords)
# Note: need LinearRing to compute ccw. Need Polygon to compute contains().
spoly = SPolygon(coords)
if i == 0:
parentSpoly = spoly
ring = polygon.LinearRing(coords)
# Some sanity checks to make sure all rings are closed, non-empty,
# and valid.
if not ring.is_ring:
raise Exception('Badly formatted non-ring : %s' % geoid)
if ring.is_empty:
raise Exception('Empty geometry found: %s' % geoid)
if not ring.is_valid:
raise Exception('Invalid ring: %s' % geoid)
if not ring.is_ccw:
# This ring is an internal (enclave) ring.
rring = copy.deepcopy(ring)
rring.coords = list(rring.coords)[::-1]
# Shapely contains does not handle point-overlaps. This
# means that enclaves which touch the containing ring
# are not handled correctly. To cure this, we check two
# points.
if not (parentSpoly.contains(SPoint(rring.coords[0])) or
parentSpoly.contains(SPoint(rring.coords[1]))):
print 'Out-of-order enclave'
# print 'ring %s does not contain %s' % (parentSpoly, ring)
# print ring
# print rring
# Note: if this triggers, we will need to store the polys
# to figure out which one is the enclosing one. Hopefully
# the census files will not exhibit this, although it is
# legal strictly according to the shapefule spec.
raise Exception('Out-of-order enclave')
coordinates = coordinates + ' 0,0,0'
parentPoly.append(KML.innerBoundaryIs(
KML.LinearRing(
KML.coordinates(coordinates)
)
))
else:
# Find the containing poly...
parentPoly.append(KML.innerBoundaryIs(
KML.LinearRing(
KML.coordinates(coordinates)
)
))
else:
if i > 0:
# Set the new parent polygon ring.
parentSpoly = spoly
parentPoly = KML.Polygon(
KML.extrude(0),
KML.altitudeMode('clampToGround'))
pm.MultiGeometry.append(parentPoly)
parentPoly.append(KML.outerBoundaryIs(
KML.LinearRing(
KML.coordinates(coordinates)
)
))
return pm
def makeExtendedDataElements(datadict):
'''Converts a dictionary to ExtendedData/Data elements'''
edata = KML.ExtendedData()
for key, value in datadict.items():
edata.append(KML.Data(KML.value(value), name=key + "_"))
return edata
def createPlacemarkForSelection(self, cmp, uuid, center, fld):
#geomtryLinks = cmp.getAttribute("Geometry").getLinks()
#for link in geomtryLinks:
# link.
l = cmp.getAttribute("l_bounding").getDouble()
b = cmp.getAttribute("b_bounding").getDouble()
h = cmp.getAttribute("h_bounding").getDouble()
alpha = cmp.getAttribute("alpha_bounding").getDouble()
nodes = []
nodes.append(Node(l/2, -b/2, h))
nodes.append(Node(l/2, b/2, h))
nodes.append(Node(-l/2, b/2, h))
nodes.append(Node(-l/2, -b/2, h))
nodes.append(Node(l/2, -b/2, h))
nodes = self.rotatePolygon(nodes, alpha)
nodes = self.translatePolygon(nodes, center)
nodes_transformed = []
exdata = KML.ExtendedData()
attributes = cmp.getAllAttributes()
for k in attributes:
attr = attributes[k]
#print attr.getType()
if attr.getType() == Attribute.DOUBLE:
#print str(k) + " " + str(attr.getDouble())
d = KML.Data(
KML.name(k),
KML.value(attr.getDouble()),
)
exdata.append(d)
for n in nodes:
nodes_transformed.append(self.transformCoorindate(n))
coordinates = ''
for n in nodes_transformed:
coordinates+="{0},{1},{2}".format(n.getX(), n.getY(), n.getZ())+"\n"
y = int(cmp.getAttribute("built_year").getDouble())
if y < 1:
y = 1900
m = 1
d = 1
pm = KML.Placemark(
KML.name(uuid+"_Data"),
exdata,
KML.styleUrl("#transRedPoly"),
KML.TimeStamp(
KML.when((date(y,m,d)).strftime('%Y-%m-%dT%H:%MZ')),
),
KML.Polygon(
KML.extrude(1),
KML.altitudeMode("relativeToGround"),
KML.outerBoundaryIs(
KML.LinearRing(
KML.coordinates(coordinates),
),
),
),
)
fld.append(pm)
def _convert_(self, request):
from pykml.factory import KML_ElementMaker as KML
from lxml import etree
## create the database
if self.use_stat:
raise (NotImplementedError)
else:
db = self.sub.to_db(wkt=True, to_disk=True)
meta = request.ocg
if request.environ['SERVER_PORT'] == '80':
portstr = ''
else:
portstr = ':{port}'.format(port=request.environ['SERVER_PORT'])
url = '{protocol}://{server}{port}{path}'.format(
protocol='http',
port=portstr,
server=request.environ['SERVER_NAME'],
path=request.environ['PATH_INFO'],
)
description = (
'<table border="1">'
'<tbody>'
'<tr><th>Archive</th><td>{archive}</td></tr>'
'<tr><th>Emissions Scenario</th><td>{scenario}</td></tr>'
'<tr><th>Climate Model</th><td>{model}</td></tr>'
'<tr><th>Run</th><td>{run}</td></tr>'
'<tr><th>Output Variable</th><td>{variable}</td></tr>'
'<tr><th>Units</th><td>{units}</td></tr>'
'<tr><th>Start Time</th><td>{start}</td></tr>'
'<tr><th>End Time</th><td>{end}</td></tr>'
'<tr>'
'<th>Request URL</th>'
'<td><a href="{url}">{url}</a></td>'
'</tr>'
'<tr>'
'<th>Other Available Formats</th>'
'<td>'
'<a href="{url}">KML</a> - Keyhole Markup Language<br/>'
'<a href="{url_kmz}">KMZ</a> - Keyhole Markup Language (zipped)<br/>'
'<a href="{url_shz}">Shapefile</a> - ESRI Shapefile<br/>'
'<a href="{url_csv}">CSV</a> - Comma Separated Values (text file)<br/>'
'<a href="{url_json}">JSON</a> - Javascript Object Notation'
'</td>'
'</tr>'
'</tbody>'
'</table>').format(
archive=meta.archive.name,
scenario=meta.scenario,
model=meta.climate_model,
run=meta.run,
variable=meta.variable,
units=meta.variable.units,
simout=meta.simulation_output.netcdf_variable,
start=meta.temporal[0],
end=meta.temporal[-1],
operation=meta.operation,
url=url,
url_kmz=url.replace('.kml', '.kmz'),
url_shz=url.replace('.kml', '.shz'),
url_csv=url.replace('.kml', '.csv'),
url_json=url.replace('.kml', '.geojson'),
)
##### TODO: build linked urls on the fly
#from piston.emitters import Emitter
#Emitter.EMITTERS.keys()
#['xml', 'sqlite', 'nc', 'shz', 'kml', 'kcsv', 'django', 'json', 'html', 'meta', 'lshz', 'csv', 'pickle', 'kmz']
doc = KML.kml(
KML.Document(
KML.name('Climate Simulation Output'),
KML.open(1),
KML.description(description),
KML.snippet(
'<i>Click for metadata!</i>',
maxLines="2",
),
KML.StyleMap(
KML.Pair(
KML.key('normal'),
KML.styleUrl('#style-normal'),
),
KML.Pair(
KML.key('highlight'),
KML.styleUrl('#style-highlight'),
),
id="smap",
),
KML.Style(
KML.LineStyle(
KML.color('ff0000ff'),
KML.width('2'),
),
KML.PolyStyle(KML.color('400000ff'), ),
id="style-normal",
),
KML.Style(
KML.LineStyle(
KML.color('ff00ff00'),
KML.width('4'),
),
KML.PolyStyle(KML.color('400000ff'), ),
KML.BalloonStyle(
KML.text((
'<script type="text/javascript" src="http://dygraphs.com/dygraph-combined.js">'
'</script>'
'<div id="graphdiv"></div>'
'<script type="text/javascript">'
'g = new Dygraph('
'document.getElementById("graphdiv"),'
'$[csv_data],'
'{{'
'ylabel: \'{param} [{units}]\','
'legend: \'always\''
'}}'
');'
'</script>').format(
param=meta.variable.name,
units=meta.variable.units,
))),
id="style-highlight",
),
#Time Folders will be appended here
), )
try:
s = db.Session()
# create a folder to hold the geometries
geom_fld = KML.Folder(KML.name('Geometries'), )
for geom in s.query(db.Geometry).all():
coord_list = geom.as_kml_coords()
multigeom_args = [
KML.Polygon(
KML.tessellate('1'),
KML.outerBoundaryIs(
KML.LinearRing(KML.coordinates(coords.text), ), ),
) for coords in coord_list
]
# TODO: sort values by time to speed loading
values = [
'{0},{1}'.format(
datetime.strftime(val.time, "%Y-%m-%d %H:%M:%S"),
val.value) for val in geom.values
]
pm = KML.Placemark(
KML.name('Geometry'),
KML.ExtendedData(
KML.Data(
KML.value('"Date,{param}\\n{data}"'.format(
param=meta.variable.name,
data='\\n'.join(values))),
name="csv_data",
), ),
KML.description(''),
KML.styleUrl('#smap'),
KML.MultiGeometry(*multigeom_args),
)
geom_fld.append(pm)
doc.Document.append(geom_fld)
# for time in s.query(db.Time).all():
# # create a folder for the time
# timefld = KML.Folder(
## KML.Style(
## KML.ListStyle(
## KML.listItemType('checkHideChildren'),
## KML.bgColor('00ffffff'),
## KML.maxSnippetLines('2'),
## ),
## ),
# KML.name(time.as_xml_date()),
# # placemarks will be appended here
# )
# for val in time.values:
# poly_desc = (
# '<table border="1">'
# '<tbody>'
# '<tr><th>Variable</th><td>{variable}</td></tr>'
# '<tr><th>Date/Time (UTC)</th><td>{time}</td></tr>'
# '<tr><th>Value</th><td>{value:.{digits}f} {units}</td></tr>'
# '</tbody>'
# '</table>'
# ).format(
# variable=meta.variable.name,
# time=val.time_ref.as_xml_date(),
# value=val.value,
# digits=3,
# units=meta.variable.units,
# )
#
# coords = val.geometry.as_kml_coords()
# timefld.append(
# KML.Placemark(
# KML.name('Geometry'),
# KML.description(poly_desc),
# KML.styleUrl('#smap'),
# KML.Polygon(
# KML.tessellate('1'),
# KML.outerBoundaryIs(
# KML.LinearRing(
# KML.coordinates(coords),
# ),
# ),
# ),
# )
# )
# doc.Document.append(timefld)
# pass
finally:
s.close()
# return the pretty print string
output = etree.tostring(doc, pretty_print=True)
# Unescape newline characters
#return(output.replace('&#10;','\\n'))
return (output)
def create_ev_sta_kml(input_dics, events):
"""
create event/station/ray in KML format readable by Google-Earth
:param input_dics:
:param events:
:return:
"""
try:
from pykml.factory import KML_ElementMaker as KML
from lxml import etree
except:
sys.exit('[ERROR] pykml should be installed first!')
if not os.path.isdir('kml_dir'):
os.mkdir('kml_dir')
else:
print('[INFO] kml_dir already exists!')
# create a document element with multiple label style
kmlobj = KML.kml(KML.Document())
counter = 0
for ei in range(len(events)):
print(events[ei]['event_id'])
counter += 1
ev_date = '%04i/%02i/%02i-%02i:%02i:%02i' \
% (events[ei]['datetime'].year,
events[ei]['datetime'].month,
events[ei]['datetime'].day,
events[ei]['datetime'].hour,
events[ei]['datetime'].minute,
events[ei]['datetime'].second
)
if input_dics['plot_focal']:
try:
focmecs = [float(events[ei]['focal_mechanism'][0]),
float(events[ei]['focal_mechanism'][1]),
float(events[ei]['focal_mechanism'][2]),
float(events[ei]['focal_mechanism'][3]),
float(events[ei]['focal_mechanism'][4]),
float(events[ei]['focal_mechanism'][5])]
except:
print("WARNING: 'focal_mechanism' does not exist!")
focmecs = [1, 1, 1, 0, 0, 0]
else:
focmecs = [1, 1, 1, 0, 0, 0]
if 0 <= events[ei]['depth'] < 70:
event_color = 'red'
elif 70 <= events[ei]['depth'] < 300:
event_color = 'green'
else:
event_color = 'blue'
try:
Beachball(focmecs,
outfile=os.path.join(
'kml_dir', events[ei]['event_id'] + '.png'),
facecolor=event_color,
edgecolor=event_color)
except Exception as error:
print(error)
print(focmecs)
continue
plt.close()
plt.clf()
if input_dics['plot_ev'] or input_dics['plot_ray']:
kmlobj.Document.append(
KML.Style(
KML.IconStyle(
KML.Icon(KML.href(os.path.join(
events[ei]['event_id'] + '.png')),
),
KML.scale(events[ei]['magnitude']/2.),
KML.heading(0.0),
),
id='beach_ball_%i' % counter
),
)
kmlobj.Document.append(
KML.Placemark(
KML.name(events[ei]['event_id']),
KML.ExtendedData(
KML.Data(
KML.value('%s' % events[ei]['event_id']),
name='event_id'
),
KML.Data(
KML.value('%s' % events[ei]['magnitude']),
name='magnitude'
),
KML.Data(
KML.value('%s' % ev_date),
name='datetime'
),
KML.Data(
KML.value('%s' % events[ei]['depth']),
name='depth'
),
KML.Data(
KML.value('%s' % events[ei]['latitude']),
name='latitude'
),
KML.Data(
KML.value('%s' % events[ei]['longitude']),
name='longitude'
),
),
KML.styleUrl('#beach_ball_%i' % counter),
# KML.Point(KML.coordinates(events[ei]['longitude'], ',',
# events[ei]['latitude'], ',',
# 700000 -
# abs(events[ei]['depth']*1000)),
# KML.altitudeMode('absolute')
# ),
KML.Point(KML.coordinates(events[ei]['longitude'], ',',
events[ei]['latitude'], ',',
0.),
KML.altitudeMode('absolute')
),
),
)
if input_dics['plot_sta'] or input_dics['plot_ray']:
target_path = locate(input_dics['datapath'],
events[ei]['event_id'])
if len(target_path) < 1:
continue
if len(target_path) > 1:
print("[LOCAL] more than one path was found for the event:")
print(target_path)
print("[INFO] use the first one:")
target_path = target_path[0]
print(target_path)
else:
print("[LOCAL] Path:")
target_path = target_path[0]
print(target_path)
update_sta_ev_file(target_path, events[ei])
sta_ev_arr = np.loadtxt(os.path.join(target_path,
'info', 'station_event'),
delimiter=',', dtype=bytes, ndmin=2).astype(np.str)
sta_ev_arr = sta_ev_arr.astype(np.object)
del_index = []
for sti in range(len(sta_ev_arr)):
if not plot_filter_station(input_dics, sta_ev_arr[sti]):
del_index.append(sti)
dist, azi, bazi = gps2DistAzimuth(events[ei]['latitude'],
events[ei]['longitude'],
float(sta_ev_arr[sti, 4]),
float(sta_ev_arr[sti, 5]))
epi_dist = dist/111.194/1000.
if input_dics['min_azi'] or input_dics['max_azi'] or \
input_dics['min_epi'] or input_dics['max_epi']:
if input_dics['min_epi']:
if epi_dist < input_dics['min_epi']:
del_index.append(sti)
if input_dics['max_epi']:
if epi_dist > input_dics['max_epi']:
del_index.append(sti)
if input_dics['min_azi']:
if azi < input_dics['min_azi']:
del_index.append(sti)
if input_dics['max_azi']:
if azi > input_dics['max_azi']:
del_index.append(sti)
del_index = list(set(del_index))
del_index.sort(reverse=True)
for di in del_index:
sta_ev_arr = np.delete(sta_ev_arr, (di), axis=0)
kmlobj.Document.append(
KML.Style(
KML.IconStyle(
KML.scale(2.5),
KML.heading(0.0),
),
id='station'
),
)
kmlobj.Document.append(
KML.Style(
KML.LineStyle(
KML.width(1.0),
# KML.color('ff33ccff'),
KML.color('2333ccff'),
),
id='great_circle_distance'
),
)
for sti in sta_ev_arr:
dist, azi, bazi = gps2DistAzimuth(events[ei]['latitude'],
events[ei]['longitude'],
float(sti[4]),
float(sti[5]))
epi_dist = dist/111.194/1000.
sta_id = '%s.%s.%s.%s' % (sti[0], sti[1], sti[2], sti[3])
kmlobj.Document.append(
KML.Placemark(
KML.name(sta_id),
KML.ExtendedData(
KML.Data(
KML.value('%s' % sta_id),
name='StationID'
),
KML.Data(
KML.value('%s' % epi_dist),
name='Distance'
),
KML.Data(
KML.value('%s' % sti[6]),
name='Elevation'
),
KML.Data(
KML.value('%s' % sti[7]),
name='Depth'
),
KML.Data(
KML.value('%s' % bazi),
name='Back-Azimuth'
),
KML.Data(
KML.value('%s' % azi),
name='Azimuth'
),
KML.Data(
KML.value('%s' % events[ei]['event_id']),
name='EventID'
),
KML.Data(
KML.value('%s' % sti[8]),
name='Source'
),
),
KML.styleUrl('station'),
KML.Point(KML.coordinates(
float(sti[5]), ',', float(sti[4]))
),
),
)
if input_dics['plot_ray']:
kmlobj.Document.append(
KML.Placemark(
KML.name(sta_id),
KML.ExtendedData(
KML.Data(
KML.value('%s' % sta_id),
name='StationID'
),
),
KML.styleUrl('great_circle_distance'),
KML.LineString(KML.coordinates(
'%s,%s,0\n'
'%s,%s,0' % (float(sti[5]),
float(sti[4]),
events[ei]['longitude'],
events[ei]['latitude'])),
KML.tessellate(1)),
),
)
kml_outfile = file(os.path.join(
'kml_dir',
'kml_output.kml'), 'w')
kml_outfile.write(etree.tostring(kmlobj, pretty_print=True))
sys.exit('[INFO] KML file is stored in ./kml_dir!')
print "Procesing '" + f_name_base + "'"
# group POIs by folder based on output log file name
group_name = f_name_base[:-len(output_log_suffix)]
kml_poi_folder = KML.Folder(KML.name(group_name))
kml_poi_doc.append(kml_poi_folder)
lines = open(f_path).readlines()
for line in lines:
lat, lon, time, frame, found, uid, pixelx, pixely = line.split(" ")
lat = dms2dec(lat)
lon = dms2dec(lon)
coord = lon + "," + lat
# create POI
pml = KML.Placemark(KML.name(uid),KML.Point(KML.coordinates(coord)))
# add all data as extended data
ext = KML.ExtendedData()
pml.append(ext)
ext.append(KML.Data(KML.value(uid), name="uid"))
ext.append(KML.Data(KML.value(time), name="time"))
ext.append(KML.Data(KML.value(frame), name="frame"))
ext.append(KML.Data(KML.value(pixelx), name="pixelX"))
ext.append(KML.Data(KML.value(pixely), name="pixelY"))
kml_poi_folder.append(pml)
# find image by id and optionally put it in kmz
img_name = image_prefix + uid + image_ext
img_path = os.path.join(work_dir, img_name) #added 4/23
if (os.path.exists(img_path)):
pml.append(KML.description("<img src='" + img_name + "' width='400' />"))
if (create_images_kmz):
zipf.write(img_path, img_name)
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 getkml(self):
avgalt = sum([i.Altitude
for i in self.waypoints]) / float(len(self.waypoints))
minlat = min([i.Latitude for i in self.waypoints])
minlon = min([i.Longitude for i in self.waypoints])
maxlon = max([i.Longitude for i in self.waypoints])
maxlat = max([
i.Latitude + (i.Altitude - avgalt) /
(60.0 * 1852.0 * math.cos(math.radians(-20)))
for i in self.waypoints
])
if abs(maxlon - minlon) > abs(maxlat - minlat):
rang = abs(maxlon - minlon) * 60.0 * 1852.0 / (
2.0 * math.sin(math.radians(self.hfov) / 2.0)) * 1.2
else:
rang = abs(maxlat - minlat) * 60.0 * 1852.0 / (
2.0 * math.sin(math.radians(self.hfov) / 2.0)) * 16.0 / 9.0
txtwaypoints = ' '.join([
'%f,%f,%f' % (i.Longitude, i.Latitude, i.Altitude)
for i in self.waypoints
])
txtsmoothed = ' '.join([
'%f,%f,%f' % (i.Longitude, i.Latitude, i.Altitude)
for i in self.smoothed
])
wfolder = KML.Folder(
KML.name('WayPoint Markers'),
KML.visibility(1),
)
pfolder = KML.Folder(
KML.name('POI Markers'),
KML.visibility(1),
)
vfolder = KML.Folder(
KML.name('WayPoint Views'),
KML.visibility(0),
)
playlist = GX.Playlist()
#TODO: CDATA
virtmission = KML.kml(
KML.Document(
KML.name(self.mission),
KML.LookAt(
KML.latitude((minlat + maxlat) / 2.0),
KML.longitude((minlon + maxlon) / 2.0),
KML.altitude(avgalt),
KML.heading(0),
KML.tilt(70),
KML.range(rang),
KML.altitudeMode("absolute"),
GX.horizFov(self.hfov),
),
GX.Tour(
KML.name('Virtual Mission'),
playlist,
),
KML.Style(
KML.LineStyle(
KML.color('FF00FFFF'),
KML.width(2),
),
KML.PolyStyle(KML.color('4C00FFFF'), ),
id='wpstyle',
),
KML.Style(
KML.LineStyle(
KML.color('FFFF00FF'),
KML.width(2),
),
KML.PolyStyle(KML.color('4CFF00FF'), ),
id='smoothstyle',
),
KML.Style(
KML.IconStyle(
KML.Icon(
KML.href(
'http://maps.google.com/mapfiles/kml/paddle/wht-blank.png'
), ), ),
KML.BalloonStyle(
KML.text(
'\n<h3>WayPoint $[Waypoint]</h3>\n<table border="0" width="200">\n<tr><td>Altitude (msl) <td>$[Altitude_Abs] m\n<tr><td>Altitude (rtg) <td>$[Altitude_Gnd] m\n<tr><td>Heading<td>$[Heading] degrees\n<tr><td>Gimbal Tilt<td> $[Gimbal] degrees\n</tr></table>\n'
),
KML.bgColor('ffffffbb'),
),
id='wpmarkers',
),
KML.Style(
KML.IconStyle(
KML.Icon(
KML.href(
'http://maps.google.com/mapfiles/kml/paddle/red-stars.png'
), ), ),
KML.BalloonStyle(
KML.text(
'\n<h3>POI $[POI]</h3>\n <table border="0" width="200">\n <tr><td>Altitude (msl) <td>$[Altitude_Abs] m\n <tr><td>Altitude (rtg) <td>$[Altitude_Gnd] m\n </tr></table>\n'
),
KML.bgColor('ffffffbb'),
),
id='poimarkers',
),
KML.Folder(
KML.name('Diagnostics'),
KML.Placemark(
KML.name('WayPoint Path'),
KML.visibility(0),
KML.styleUrl('#wpstyle'),
KML.LineString(
KML.extrude(1),
KML.tessellate(1),
KML.altitudeMode('absolute'),
KML.coordinates(txtwaypoints),
),
),
wfolder,
pfolder,
vfolder,
KML.Placemark(
KML.name('Smooth Flight Path'),
KML.visibility(1),
KML.styleUrl('#smoothstyle'),
KML.LineString(
KML.extrude(1),
KML.tessellate(1),
KML.altitudeMode('absolute'),
KML.coordinates(txtsmoothed),
),
),
),
))
for wp in self.smoothed:
playlist.append(
GX.FlyTo(
GX.duration(wp.LegTime),
GX.flyToMode('smooth'),
KML.Camera(
KML.latitude(wp.Latitude),
KML.longitude(wp.Longitude),
KML.altitude(wp.Altitude),
KML.heading(wp.Heading),
KML.tilt(wp.GimbalTilt),
KML.roll(0),
KML.altitudeMode("absolute"),
GX.horizFov(self.hfov),
),
), )
playlist.append(GX.Wait(GX.duration(0), ), )
for wp in self.waypoints:
wfolder.append(
KML.Placemark(
KML.name('WP%02d' % (wp.Num)),
KML.visibility(1),
KML.styleUrl('#wpmarkers'),
KML.ExtendedData(
KML.Data(KML.value(wp.Num), name='Waypoint'),
KML.Data(KML.value(round(wp.Altitude, 0)),
name='Altitude_Abs'),
KML.Data(KML.value(round(wp.Altitude - wp.GroundAlt,
0)),
name='Altitude_Gnd'),
KML.Data(KML.value(round(wp.Heading, 0)),
name='Heading'),
KML.Data(KML.value(round(wp.GimbalTilt - 90.0, 0)),
name='Gimbal'),
),
KML.Point(
KML.altitudeMode("absolute"),
KML.extrude(1),
KML.coordinates(
'%f,%f,%f' %
(wp.Longitude, wp.Latitude, wp.Altitude)),
),
), )
for poi in self.pois:
num = self.pois.index(poi) + 1
pfolder.append(
KML.Placemark(
KML.name('POI%02d' % num),
KML.visibility(1),
KML.styleUrl('#poimarkers'),
KML.ExtendedData(
KML.Data(KML.value(num), name='POI'),
KML.Data(KML.value(round(poi.Altitude, 0)),
name='Altitude_Abs'),
KML.Data(KML.value(
round(poi.Altitude - poi.GroundAlt, 0)),
name='Altitude_Gnd'),
),
KML.Point(
KML.altitudeMode("absolute"),
KML.extrude(1),
KML.coordinates(
'%f,%f,%f' %
(poi.Longitude, poi.Latitude, poi.Altitude)),
),
), )
for wp in self.smoothed:
if wp.Num is None:
continue
vfolder.append(
KML.Document(
KML.name('WP%03d' % (wp.Num)),
KML.visibility(0),
KML.Camera(
KML.latitude(wp.Latitude),
KML.longitude(wp.Longitude),
KML.altitude(wp.Altitude),
KML.heading(wp.Heading),
KML.tilt(wp.GimbalTilt),
KML.roll(0),
KML.altitudeMode("absolute"),
GX.horizFov(self.hfov),
),
), )
return etree.tostring(virtmission, pretty_print=True)
