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 __missing__(self, color: str):
style = kml.Style(id=color)
if current_document is not None:
current_document.append_style(style)
style.append_style(LineStyle(color=color, width=2))
style.append_style(PolyStyle(color=color))
styleUrl = kml.StyleUrl(url=color)
return styleUrl
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 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 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)
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 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)
