def save_kml(markers, filepath=None, extra_locations={}):
if filepath is None:
filepath = str(time.time())
kml_obj = simplekml.Kml()
for marker in markers:
centre_lat = marker.location[0]
centre_lon = marker.location[1]
outer_polycircle = polycircles.Polycircle(
latitude=centre_lat,
longitude=centre_lon,
radius=(marker.distance + (marker.precision / 2.0)) * M_IN_MILE,
number_of_vertices=50)
inner_polycircle = polycircles.Polycircle(
latitude=centre_lat,
longitude=centre_lon,
radius=(marker.distance - (marker.precision / 2.0)) * M_IN_MILE,
number_of_vertices=50)
pol = kml_obj.newpolygon(name="%.6f, %.6f | %.3f" %
(centre_lat, centre_lon, marker.distance),
outerboundaryis=outer_polycircle.to_kml(),
innerboundaryis=inner_polycircle.to_kml())
pol.style.polystyle.color = simplekml.Color.changealphaint(
100, simplekml.Color.red)
for key, loc in extra_locations.iteritems():
kml_obj.newpoint(name=key, coords=[(loc[1], loc[0])])
kml_obj.save(parent_folder + "output/" + filepath)
def draw_circles(kml, filename):
"""Draw, into the Kml object kml, 0.1 mile radius circles around the
waypoints in the .gpx file named by filename"""
f1 = kml.newfolder(name="GPX Point Centers")
f2 = kml.newfolder(name="0.1 Mile Circles")
points = getpoints(filename)
for point in points:
lat, lon, name, desc = point
description = "%s: %s" % (name, desc)
# create the center point
f1.newpoint(name=description, coords=[(lon, lat)])
# create the outline
polycircle = polycircles.Polycircle(latitude=lat,
longitude=lon,
radius=RADIUS,
number_of_vertices=72)
pol = f2.newpolygon(
name=description,
outerboundaryis=polycircle.to_kml(),
)
pol.description = description
pol.style.polystyle.color = simplekml.Color.red
pol.style.polystyle.outline = 1
pol.style.polystyle.fill = 1
def test_kml_polygons_4_multiple_vertices(self):
"""Creates polycircles with a varying amount of vertices."""
start_lat = -24.336113
start_lon = 14.976681
direct = geodesic.Geodesic.WGS84.Direct
kml = simplekml.Kml()
for row in range(6):
row_start = direct(start_lat, start_lon, 180, 100 * row)
row_start_lat, row_start_lon = row_start['lat2'], row_start['lon2']
for column in range(6):
circle_center = direct(row_start_lat, row_start_lon, 90,
100 * column)
circle_center_lat = circle_center['lat2']
circle_center_lon = circle_center['lon2']
number_of_vertices = (row * 6) + column + 3
polycircle = polycircles.Polycircle(circle_center_lat,
circle_center_lon, 40,
number_of_vertices)
pol = kml.newpolygon(name="%d vertices" % number_of_vertices,
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200,
simplekml.Color.aquamarine)
kml.save(
os.path.join(self.output_dir,
"test_kml_multiple_vertices.kml"))
def hangar_influence(hangar, path):
print hangar.name, hangar.id
name = "hangar_" + str(hangar.id) + "_inf.kml"
print name
polycircle = polycircles.Polycircle(latitude=hangar.latitude,
longitude=hangar.longitude,
radius=hangar.radius,
number_of_vertices=36)
points_list = polycircle.to_lat_lon()
latlonalt = []
for tuple in points_list:
tup = (tuple[1], tuple[0], 5)
latlonalt.append(tup)
kml = simplekml.Kml(open=1)
shape_polycircle = kml.newmultigeometry(name=hangar.name)
pol = shape_polycircle.newpolygon()
pol.outerboundaryis = latlonalt
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 5
pol.style.polystyle.color = '22ff0000'
pol.style.polystyle.fill = 1
pol.style.polystyle.outline = 1
pol.style.linestyle.width = 10
pol.style.linestyle.color = simplekml.Color.red
'''
pol = kml.newpolygon(name=hangar.description, outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = simplekml.Color.changealphaint(200, simplekml.Color.darksalmon)
'''
kml.save(path)
return name
def draw_circle(name, lat, lng):
polycircle = polycircles.Polycircle(latitude=lat,
longitude=lng,
radius=200,
number_of_vertices=36)
pol = kml.newpolygon(name=name, outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = simplekml.Color.rgb(
255, 140, 0, 60) #https://htmlcolorcodes.com/
def __init__(self, name, lon, lat, rad, kml):
Location.__init__(self, name, lon, lat)
self.poly = polycircles.Polycircle(longitude=lon,
latitude=lat,
radius=rad,
number_of_vertices=36)
self.kml = kml.newpolygon(name=name,
outerboundaryis=self.poly.to_kml())
self.kml.style.polystyle.color = simplekml.Color.changealphaint(
200, simplekml.Color.green)
def setUp(self):
self.latitude = 32.074322
self.longitude = 34.792081
self.radius_meters = 100
self.number_of_vertices = 36
self.polycircle = \
polycircles.Polycircle(latitude=self.latitude,
longitude=self.longitude,
radius=self.radius_meters,
number_of_vertices=self.number_of_vertices)
def test_kml_polygon_2(self):
"""Creates a torus-shaped polygon."""
outer_polycircle = polycircles.Polycircle(latitude=40.768085,
longitude=-73.981885,
radius=200,
number_of_vertices=36)
inner_polycircle = polycircles.Polycircle(latitude=40.768085,
longitude=-73.981885,
radius=180,
number_of_vertices=36)
kml = simplekml.Kml()
pol = kml.newpolygon(name="Torus around Columbus Circle, Manhattan",
outerboundaryis=outer_polycircle.to_kml(),
innerboundaryis=inner_polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, simplekml.Color.red)
kml.save(
os.path.join(self.output_dir,
"test_kml_polygon_2_torus_manhattan.kml"))
def drawCircle(Name, Lat, Lon, Radius, color):
circle = pc.Polycircle(latitude=Lat,
longitude=Lon,
radius=Radius,
number_of_vertices=iterationConstant)
pol = kml.newpolygon(name=Name, outerboundaryis=circle.to_kml())
pol.style.polystyle.color = "000000ff" # Transparent
pol.style.linestyle.color = color
pol.altitudemode = 'absoluteAltitude'
pol.tessellate = 1
return circle
def test_kml_polygon_1(self):
"""Asserts that the KML output is valid for the simplekml package."""
polycircle = polycircles.Polycircle(latitude=32.074523,
longitude=34.791469,
radius=20,
number_of_vertices=36)
kml = simplekml.Kml()
pol = kml.newpolygon(name="Azrieli towers",
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, simplekml.Color.green)
kml.save(os.path.join(self.output_dir, "test_kml_polygon_1.kml"))
def test_kml_polygon_3_manhattan(self):
"""Asserts that the KML output is valid for the simplekml package."""
polycircle = polycircles.Polycircle(latitude=40.768085,
longitude=-73.981885,
radius=200,
number_of_vertices=36)
kml = simplekml.Kml()
pol = kml.newpolygon(name="Columbus Circle, Manhattan",
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, simplekml.Color.green)
kml.save(
os.path.join(self.output_dir, "test_kml_polygon_3_manhattan.kml"))
def test_olympic_bagels2(self):
"""Creates bagel-shaped polygons in Rio (just for fun).."""
circles = ((-22.971499, -43.183030, simplekml.Color.blue),
(-22.971498, -43.182737, simplekml.Color.black),
(-22.971498, -43.182444, simplekml.Color.red),
(-22.971666, -43.182892, simplekml.Color.yellow),
(-22.971665, -43.182599, simplekml.Color.green))
kml = simplekml.Kml()
for circle in circles:
outer_polycircle = polycircles.Polycircle(circle[0],
circle[1],
radius=20)
inner_polycircle = polycircles.Polycircle(circle[0],
circle[1],
radius=16)
pol = kml.newpolygon(outerboundaryis=outer_polycircle.to_kml(),
innerboundaryis=inner_polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(150, circle[2])
kml.save(os.path.join(self.output_dir, "test_olympic_bagels_2.kml"))
def creatKml(obsList):
kml = simplekml.Kml()
i = 0
for item in obsDict:
polycircle = polycircles.Polycircle(latitude=item.latitude,
longitude=item.longitude,
radius=item.cylinder_radius,
number_of_vertices=36)
pol = kml.newpolygon(name=str(i), outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, simplekml.Color.green)
i = i + 1
kml.save("obstackle.kml")
return
def generate(self):
kml = simplekml.Kml(open=1)
polygon_circle = []
for data in self.data_set:
shape_polycircle = kml.newmultigeometry(name=data['data'])
try:
radius = round(data['data'])
except TypeError:
radius = int(data['data'])
polycircle = polycircles.Polycircle(
latitude=data['coordinates']['lat'],
longitude=data['coordinates']['lng'],
radius=(radius + 1) * self.multiplier,
number_of_vertices=36)
latloncircle = polycircle.to_lon_lat()
latlonaltcircle = []
for element in latloncircle:
tup = (
element[0],
element[1],
self.altitude,
)
latlonaltcircle.append(tup)
print latlonaltcircle
pol = shape_polycircle.newpolygon()
pol.outerboundaryis = latlonaltcircle
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 5
pol.style.polystyle.color = simplekml.Color.changealphaint(
200, self.set_color(self.color))
pol.style.linestyle.color = simplekml.Color.changealphaint(
230, self.set_color(self.color))
polygon_circle.append(polycircle)
kml.save("kmls_management/static/" + self.kml_name)
def add_route(self, route): fol = self.kml.newfolder(name=self.route_folder_name(route)) polycircle = polycircles.Polycircle(latitude=route.start_latitude, longitude=route.start_longitude, radius=route.start_radius, number_of_vertices=36) polygon = fol.newpolygon(name=route.start_label, outerboundaryis=polycircle.to_kml()) polygon.style = self.circle_style polycircle = polycircles.Polycircle(latitude=route.end_latitude, longitude=route.end_longitude, radius=route.end_radius, number_of_vertices=36) polygon = fol.newpolygon(name=route.end_label, outerboundaryis=polycircle.to_kml()) polygon.style = self.circle_style route.matches.sort(key=lambda x: x.duration()) for match in route.matches: line = fol.newlinestring( name=match.name(), description=match.description(), coords=match.coords()) line.style.linestyle.width=3 line.style.linestyle.color = self.line_color(match.normal_duration())
def buildCircle(location, name):
circleID = makeKey(name) + '_circle'
boundaryCircle = polycircles.Polycircle(latitude=location['lat'],
longitude=location['lon'],
radius=CIRCLE_RADIUS * 1000,
number_of_vertices=36)
coords = [(coord[1], coord[0]) for coord in boundaryCircle.vertices]
circleShape = Polygon(coords)
kmlGeometry = geometry.Geometry(NAME_SPACE,
id=circleID,
geometry=circleShape,
extrude=False,
tessellate=True,
altitude_mode='clampToGround')
return kmlGeometry
def hangar_influence(hangar, path):
name = "hangar_" + str(hangar.id) + "_inf.kml"
polycircle = polycircles.Polycircle(latitude=hangar.latitude,
longitude=hangar.longitude,
radius=hangar.radius,
number_of_vertices=36)
# kml = simplekml.Kml()
points_list = polycircle.to_lat_lon()
latlonalt = []
for idx, points_tuple in enumerate(points_list):
if idx == 0:
first_point = (points_tuple[1], points_tuple[0])
tup = (points_tuple[1], points_tuple[0])
latlonalt.insert(0, tup)
latlonalt.insert(0, first_point)
#
kml = simplekml.Kml(open=1)
shape_polycircle = kml.newmultigeometry(name=hangar.name)
pol = shape_polycircle.newpolygon()
# pol = kml.newpolygon(name=name) # /
pol.outerboundaryis = latlonalt # /
# Line Style
# pol.style.linestyle.color = simplekml.Color.red # /
# pol.style.linestyle.width = 20 # /
# If you want to see the filled polygon needs to enable relative to ground
pol.style.polystyle.fill = 1
pol.style.polystyle.outline = 1
pol.style.polystyle.color = simplekml.Color.changealphaint(
100, simplekml.Color.blue)
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 5
pol.style.polystyle.color = '22ff0000'
pol.style.polystyle.fill = 1
pol.style.polystyle.outline = 1
pol.style.linestyle.width = 20
pol.style.linestyle.color = simplekml.Color.red
'''
pol = kml.newpolygon(name=hangar.description,
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color =
simplekml.Color.changealphaint(200, simplekml.Color.darksalmon)
'''
kml.save(path)
return name
def setUp(self):
csvfile = 'polycircles/test/sismos_continente2.csv'
output_dir = 'kmls'
if not os.path.exists(output_dir):
os.makedirs(output_dir)
with open(csvfile) as f:
datafile = csv.reader(f, delimiter=',')
quakelist = list(datafile)
kml = simplekml.Kml()
alpha = 100
self.polycircles = []
self.number_of_vertices = 36
for quake in quakelist[1:]:
lng = float(quake[0]) # X
lat = float(quake[1]) # Y
yyyy = quake[2] # Ano
magw = quake[25] # mag_03
polycircle = polycircles.Polycircle(
latitude=lat,
longitude=lng,
radius=40000,
number_of_vertices=self.number_of_vertices)
self.polycircles.append(polycircle)
pol = kml.newpolygon(name=yyyy,
outerboundaryis=polycircle.to_kml())
if float(magw) < 3.0:
pol.style.polystyle.color = simplekml.Color.changealphaint(
alpha, simplekml.Color.lightyellow)
pol.style.linestyle.color = simplekml.Color.lightyellow
elif 3.0 < float(magw) < 3.5:
pol.style.polystyle.color = simplekml.Color.changealphaint(
alpha, simplekml.Color.yellow)
pol.style.linestyle.color = simplekml.Color.yellow
elif 3.5 < float(magw) < 4.0:
pol.style.polystyle.color = simplekml.Color.changealphaint(
alpha, simplekml.Color.orangered)
pol.style.linestyle.color = simplekml.Color.orangered
else:
pol.style.polystyle.color = simplekml.Color.changealphaint(
alpha, simplekml.Color.red)
pol.style.linestyle.color = simplekml.Color.red
kml.save(os.path.join(output_dir, 'sismos.kml'))
def add_staypoints(self, staypoints):
for staypoint in staypoints:
staypoint_points = map(lambda p: p.location, staypoint.points)
lat, long, radius = smallestenclosingcircle.make_circle(
staypoint_points)
western_most_point_on_circle = (lat, long - radius)
radius_in_meters = distance.vincenty(western_most_point_on_circle,
staypoint.location).meters
polycircle = polycircles.Polycircle(latitude=lat,
longitude=long,
radius=radius_in_meters,
number_of_vertices=36)
pol = self.kml.newpolygon(name="Staypoint vicinity",
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = \
simplekml.Color.changealphaint(30, simplekml.Color.green)
self.kml.newpoint(name="Staypoint",
coords=[tuple(reversed(staypoint.location))])
def generateCylinder(self, name, description, coordinates, magnitude):
fechaStr = datetime.datetime.fromtimestamp(
int(description) / 1000).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
polycircle = polycircles.Polycircle(latitude=float(coordinates[0]),
longitude=float(coordinates[1]),
radius=float(abs(magnitude)) *
20000,
number_of_vertices=36)
pol = self.kml_var.newpolygon(name=name,
description=str(fechaStr),
outerboundaryis=polycircle.to_kml())
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 1
pol.style.polystyle.fill = 1
self.addColor(pol, magnitude)
pol.style.linestyle.width = 5000
def add_route(self, route):
fol = geojson.FeatureCollection([], properties={"name":self.route_folder_name(route)})
self.collection.features.append(fol)
polycircle = polycircles.Polycircle(latitude=route.start_latitude,
longitude=route.start_longitude,
radius=route.start_radius,
number_of_vertices=36)
# polygon = fol.newpolygon(name=route.start_label, outerboundaryis=polycircle.to_kml())
# polygon.style = self.circle_style
#
# polycircle = polycircles.Polycircle(latitude=route.end_latitude,
# longitude=route.end_longitude,
# radius=route.end_radius,
# number_of_vertices=36)
# polygon = fol.newpolygon(name=route.end_label, outerboundaryis=polycircle.to_kml())
# polygon.style = self.circle_style
route.matches.sort(key=lambda x: x.duration())
for match in route.matches:
feature = geojson.Feature( id=match.name(),
geometry=geojson.LineString(match.coords()),
properties={"name":match.name(), "description":match.description()})
fol.features.append(feature)
def getStationKml(feature):
if (feature.style == None or feature.style == ""):
style = "0000ff"
else:
style = feature.style[1:]
styleName = style + feature.type
result = ('''
<Placemark>
<name>%(name)s</name>
<description>%(description)s</description>
<styleUrl>%(style)s</styleUrl>
%(point)s
</Placemark>''' % {
'name': feature.name,
'description': feature.description,
'point': toKml(feature.point, "Point"),
'style': styleName
})
if feature.tolerance:
toleranceCircle = polycircles.Polycircle(latitude=feature.point[1],
longitude=feature.point[0],
radius=int(feature.tolerance),
number_of_vertices=36)
result += ('''
<Placemark>
<name>%(name)s</name>
<styleUrl>%(style)s</styleUrl>
<LineString>
<tessellate>1</tessellate>
%(geom)s
</Placemark>''' % {
'name': feature.name,
'style': "tolerance" + feature.style[1:],
'geom': toleranceKmlFormatter(toleranceCircle)
})
if feature.boundary:
boundaryCircle = polycircles.Polycircle(latitude=feature.point[1],
longitude=feature.point[0],
radius=int(feature.boundary),
number_of_vertices=36)
result += ('''
<Placemark>
<name>%(name)s</name>
<styleUrl>%(style)s</styleUrl>
<MultiGeometry>
<LineString>
<tessellate>1</tessellate>
%(geom)s
</Placemark>''' % {
'name': feature.name,
'style': "boundary" + feature.style[1:],
'geom': boundaryKmlFormatter(boundaryCircle)
})
return result
def test_less_than_3_vertices_no_1(self):
polycircle = polycircles.Polycircle(latitude=30,
longitude=30,
radius=100,
number_of_vertices=2)
def test_erroneous_longitude_2(self):
polycircle = polycircles.Polycircle(latitude=30,
longitude=200,
radius=100)
def make_kml(tupple_lists, conditions_tupple_list, rng, header):
kml = simplekml.Kml()
for tupple_list in tupple_lists:
for condition in conditions_tupple_list:
if tupple_list[3] > condition[0] and tupple_list[3] <= condition[1]:
polycircle = polycircles.Polycircle(latitude=tupple_list[1],
longitude=tupple_list[2],
radius=rng * 1000,
number_of_vertices=36)
pol = kml.newpolygon(name=tupple_list[0],
outerboundaryis=polycircle.to_kml())
pnt = kml.newpoint()
pnt.name = tupple_list[0]
pnt.description = f"{header} is {tupple_list[3]}"
pnt.coords = [(tupple_list[2], tupple_list[1])]
if condition[2] == 'yellow':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff02e7ff")
elif condition[2] == 'orange':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff026df7")
elif condition[2] == 'dark_orange':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff0151b8")
elif condition[2] == 'green':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff18bd1e")
elif condition[2] == 'light_green':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff40f686")
elif condition[2] == 'dark_green':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff038e5c")
elif condition[2] == 'blue':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ffbd2b18")
elif condition[2] == 'light_blue':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ffd77903")
elif condition[2] == 'dark_blue':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff5c0b0a")
elif condition[2] == 'light_purple':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "fffb58a8")
elif condition[2] == 'purple':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "fff7278d")
elif condition[2] == 'pink':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ffd400ff")
elif condition[2] == 'dark_red':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff480595")
elif condition[2] == 'red':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff0c0cff")
elif condition[2] == 'black':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff000000")
elif condition[2] == 'gray':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff7a7a7d")
elif condition[2] == 'white':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ffffffff")
elif condition[2] == 'brown':
pol.style.polystyle.color = \
simplekml.Color.changealphaint(200, "ff214365")
# if(tupple_list[3] <= 30000000 and tupple_list[3] > 20000000):
# polycircle = polycircles.Polycircle(latitude=tupple_list[1],
# longitude=tupple_list[2],
# radius=range * 10000,
# number_of_vertices=36)
# pol = kml.newpolygon(name=tupple_list[0], outerboundaryis=polycircle.to_kml())
# pol.style.polystyle.color = \
# simplekml.Color.changealphaint(200, simplekml.Color.red)
# elif(tupple_list[3] <= 20000000 and tupple_list[3] > 10000000):
# print(counter)
# polycircle = polycircles.Polycircle(latitude=tupple_list[1],
# longitude=tupple_list[2],
# radius=range * 10000,
# number_of_vertices=36)
# pol = kml.newpolygon(name=tupple_list[0], outerboundaryis=polycircle.to_kml())
# pol.style.polystyle.color = \
# simplekml.Color.changealphaint(200, simplekml.Color.yellow)
# elif(tupple_list[3] <= 10000000 and tupple_list[3] > 1000000):
# polycircle = polycircles.Polycircle(latitude=tupple_list[1],
# longitude=tupple_list[2],
# radius=range * 10000,
# number_of_vertices=36)
# pol = kml.newpolygon(name=tupple_list[0], outerboundaryis=polycircle.to_kml())
# pol.style.polystyle.color = \
# simplekml.Color.changealphaint(200, simplekml.Color.orange)
# elif(tupple_list[3] <= 1000000):
# polycircle = polycircles.Polycircle(latitude=tupple_list[1],
# longitude=tupple_list[2],
# radius=range * 10000,
# number_of_vertices=36)
# pol = kml.newpolygon(name=tupple_list[0], outerboundaryis=polycircle.to_kml())
# pol.style.polystyle.color = \
# simplekml.Color.changealphaint(200, simplekml.Color.green)
# else:
# polycircle = polycircles.Polycircle(latitude=tupple_list[1],
# longitude=tupple_list[2],
# radius=range * 1000,
# number_of_vertices=36)
# pol = kml.newpolygon(name=tupple_list[0], outerboundaryis=polycircle.to_kml())
# pol.style.polystyle.color = \
# simplekml.Color.changealphaint(200, simplekml.Color.black)
kml.save(f"{header}.kml")
# Create the file
kml = simplekml.Kml()
depart_times = defaultdict(list)
arrive_times = defaultdict(list)
for icao in timestamp.keys():
ls = kml.newlinestring(name=icao)
T = len(timestamp[icao])
for t in range(T):
ls.coords.addcoordinates([(longit[icao][t], lat[icao][t])])
if t > 0 and in_airport[icao][t] != in_airport[icao][t - 1]:
if in_airport[icao][t - 1]:
depart_times[icao].append(timestamp[icao][t])
else:
arrive_times[icao].append(timestamp[icao][t])
print(arrive_times)
print(depart_times)
auck_air_circle = polycircles.Polycircle(latitude=auck_air_lat,
longitude=auck_air_long,
radius=auck_air_rad,
number_of_vertices=36)
auck_air = kml.newpolygon(name="Auckland Airport",
outerboundaryis=auck_air_circle.to_kml())
auck_air.style.polystyle.color = simplekml.Color.changealphaint(
200, simplekml.Color.green)
kml.save('fooline.kml')
def generateCylinder(self, shape, value, coordinates, flag):
print("generateCylinder")
latitude = coordinates['lat']
longitude = coordinates['lng']
radius = 4200
vertices = 200
multiplier = 150.0
if "," in value:
value = value.replace(",", ".")
value = int(float(value))
else:
value = int(value)
if flag == "first":
value = 120.0
elif flag == "second":
latitude = latitude - float(value_separation)
longitude = longitude - float(value_separation)
value = 90.0
elif flag == "third":
latitude = latitude + float(value_separation)
longitude = longitude + float(value_separation)
value = 60.0
elif flag == "golden":
latitude = latitude - value_lat_center_medal
longitude = longitude + value_lng_center_medal
radius = 1000
vertices = 100
print("value gold ", value)
elif flag == "silver":
latitude = latitude - (value_lat_center_medal + 0.0180)
longitude = longitude + (value_lng_center_medal - 0.0230)
radius = 1000
vertices = 100
print("value silver ", value)
elif flag == "bronze":
latitude = latitude - (value_lat_center_medal - 0.0180)
longitude = longitude + (value_lng_center_medal + 0.0230)
radius = 1000
vertices = 100
print("value bronze ", value)
polycircle = polycircles.Polycircle(latitude, longitude, radius,
vertices)
latloncircle = polycircle.to_lon_lat()
latlonaltcircle = []
polygon_circle = []
# 'Pal' cap a dalt i cercle al final del pal (a dalt de tot)
for element in latloncircle:
tup = (
element[0],
element[1],
(value * multiplier) + 10.0,
)
latlonaltcircle.append(tup)
# Cilindre (interior / exterior)
for element in latloncircle:
tup = (
element[0],
element[1],
value * multiplier,
)
latlonaltcircle.append(tup)
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
#Un altre cilindre (interior / exterior ?)
for element in latloncircle:
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
tup = (
element[0],
element[1],
value * multiplier,
)
latlonaltcircle.append(tup)
for element in latloncircle:
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
pol = shape.newpolygon()
pol.outerboundaryis = latlonaltcircle
pol.altitudemode = simplekml.AltitudeMode.absolute
pol.extrude = 5
pol.style.linestyle.width = 5000
polygon_circle.append(polycircle)
#latlonaltcircle = []
# Cyrcle (tapadera del cilindre) de dalt de tot (interior i exterior)
for element in latloncircle:
tup = (
element[0],
element[1],
(value * multiplier) + 20.0,
)
latlonaltcircle.append(tup)
pol = shape.newpolygon()
pol.outerboundaryis = latlonaltcircle
pol.altitudemode = simplekml.AltitudeMode.absolute
pol.extrude = 5
self.addColor(pol, flag)
pol.style.linestyle.width = 5000
polygon_circle.append(polycircle)
coord_to_kml = ""
for element in latlonaltcircle:
if coord_to_kml == str(""):
coord_to_kml = coord_to_kml + str(element[0]) + "," + str(
element[1]) + "," + str(element[2])
else:
coord_to_kml = coord_to_kml + " " + str(
element[0]) + "," + str(element[1]) + "," + str(element[2])
return coord_to_kml
def generateCylinder(self, shape, temp, coordinates, flag):
if flag == 'min':
polycircle = polycircles.Polycircle(
latitude=float(coordinates['lat']) - 0.025,
longitude=float(coordinates['lng']) - 0.025,
radius=1000,
number_of_vertices=100)
elif flag == 'med':
polycircle = polycircles.Polycircle(
latitude=float(coordinates['lat']),
longitude=float(coordinates['lng']),
radius=1000,
number_of_vertices=100)
elif flag == 'max':
polycircle = polycircles.Polycircle(
latitude=float(coordinates['lat']) + 0.025,
longitude=float(coordinates['lng']) + 0.025,
radius=1000,
number_of_vertices=100)
latloncircle = polycircle.to_lon_lat()
latlonaltcircle = []
polygon_circle = []
multiplier = 2000
temperature = int(temp)
for element in latloncircle:
tup = (
element[0],
element[1],
(temperature * multiplier) + 10,
)
latlonaltcircle.append(tup)
for element in latloncircle:
tup = (
element[0],
element[1],
temperature * multiplier,
)
latlonaltcircle.append(tup)
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
for element in latloncircle:
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
tup = (
element[0],
element[1],
temperature * multiplier,
)
latlonaltcircle.append(tup)
for element in latloncircle:
tup = (
element[0],
element[1],
0,
)
latlonaltcircle.append(tup)
pol = shape.newpolygon()
pol.outerboundaryis = latlonaltcircle
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 5
pol.style.linestyle.width = 5000
polygon_circle.append(polycircle)
latlonaltcircle = []
for element in latloncircle:
tup = (
element[0],
element[1],
(temperature * multiplier) + 20,
)
latlonaltcircle.append(tup)
pol = shape.newpolygon()
pol.outerboundaryis = latlonaltcircle
pol.altitudemode = simplekml.AltitudeMode.relativetoground
pol.extrude = 5
self.addColor(pol, flag)
pol.style.linestyle.width = 5000
polygon_circle.append(polycircle)
def step_impl(context):
context.polycircle = \
polycircles.Polycircle(float(context.latitude),
float(context.longitude),
float(context.radius),
int(context.num_vertices))
def createKml(self, jsonData, numberObtained):
kml = simplekml.Kml()
tour = kml.newgxtour(name="LastWeekEarthquakesTour")
playlist = tour.newgxplaylist()
balloonDuration = 1
flyToDuration = 3
if numberObtained > 1000:
balloonDuration = numberObtained / 1000
self.stdout.write("Default duration: " + str(balloonDuration))
earthquakeNumber = 1
for row in jsonData:
if earthquakeNumber > 666:
break
self.stdout.write(str(earthquakeNumber))
place = row["place"]
latitude = row["latitude"]
longitude = row["longitude"]
magnitude = row["magnitude"]
try:
geoJson = replaceJsonString(str(row["geojson"]))
infowindow = self.populateInfoWindow(row, geoJson)
except JSONDecodeError:
self.stdout.write(self.style.ERROR('Error decoding json'))
self.stdout.write(str(row["geojson"]))
continue
try:
if magnitude is not None:
absMagnitude = abs(float(magnitude))
color = simplekml.Color.grey
if absMagnitude <= 2:
color = simplekml.Color.green
elif 2 < absMagnitude <= 5:
color = simplekml.Color.orange
elif absMagnitude > 5:
color = simplekml.Color.red
playlist.newgxwait(gxduration=3 * balloonDuration)
polycircle = polycircles.Polycircle(latitude=latitude,
longitude=longitude,
radius=2000 *
absMagnitude,
number_of_vertices=100)
pol = kml.newpolygon(name="",
description=infowindow,
outerboundaryis=polycircle.to_kml())
pol.style.polystyle.color = color
pol.style.polystyle.fill = 0
pol.style.polystyle.outline = 1
pol.style.linestyle.color = color
pol.style.linestyle.width = 10
pol.style.balloonstyle.bgcolor = simplekml.Color.lightblue
pol.style.balloonstyle.text = "$[description]"
pol.visibility = 0
''' Fly To the atmosphere '''
flyto = playlist.newgxflyto(
gxduration=flyToDuration,
gxflytomode=simplekml.GxFlyToMode.smooth)
flyto.camera.longitude = longitude
flyto.camera.latitude = latitude
flyto.camera.altitude = 15000000
flyto.camera.range = 15000000
flyto.camera.tilt = 0
playlist.newgxwait(gxduration=flyToDuration)
''' Go Back To the point '''
flyto = playlist.newgxflyto(
gxduration=flyToDuration,
gxflytomode=simplekml.GxFlyToMode.smooth)
flyto.camera.longitude = longitude
flyto.camera.latitude = latitude
flyto.camera.altitude = 100000
flyto.camera.range = 100000
flyto.camera.tilt = 0
playlist.newgxwait(gxduration=flyToDuration)
self.simulateEarthquake(playlist, latitude, longitude,
absMagnitude)
animatedupdateshow = playlist.newgxanimatedupdate(
gxduration=balloonDuration / 10)
animatedupdateshow.update.change = '<Placemark targetId="{0}">' \
'<visibility>1</visibility></Placemark>' \
.format(pol.placemark.id)
for i in range(1, 11):
polycircleAux = polycircles.Polycircle(
latitude=latitude,
longitude=longitude,
radius=(200 * i) * absMagnitude,
number_of_vertices=100)
polAux = kml.newpolygon(
name=place, outerboundaryis=polycircleAux.to_kml())
polAux.style.polystyle.color = color
polAux.style.polystyle.fill = 1
polAux.style.polystyle.outline = 1
polAux.style.linestyle.color = color
polAux.style.linestyle.width = 1
polAux.visibility = 0
polAux.style.balloonstyle.displaymode = simplekml.DisplayMode.hide
animatedupdateshow = playlist.newgxanimatedupdate(
gxduration=balloonDuration / 10)
animatedupdateshow.update.change = '<Placemark targetId="{0}">' \
'<visibility>1</visibility></Placemark>' \
.format(polAux.placemark.id)
animatedupdatehide = playlist.newgxanimatedupdate(
gxduration=balloonDuration / 10)
animatedupdatehide.update.change = '<Placemark targetId="{0}">' \
'<visibility>0</visibility></Placemark>' \
.format(polAux.placemark.id)
playlist.newgxwait(gxduration=balloonDuration / 10)
animatedupdateshow = playlist.newgxanimatedupdate(
gxduration=balloonDuration * 2)
animatedupdateshow.update.change = '<Placemark targetId="{0}"><visibility>1</visibility>' \
'<gx:balloonVisibility>1</gx:balloonVisibility></Placemark>' \
.format(pol.placemark.id)
playlist.newgxwait(gxduration=10)
animatedupdatehide = playlist.newgxanimatedupdate(
gxduration=balloonDuration * 2)
animatedupdatehide.update.change = '<Placemark targetId="{0}">' \
'<gx:balloonVisibility>0</gx:balloonVisibility></Placemark>' \
.format(pol.placemark.id)
animatedupdateshow = playlist.newgxanimatedupdate(
gxduration=balloonDuration / 10)
animatedupdateshow.update.change = '<Placemark targetId="{0}">' \
'<visibility>1</visibility></Placemark>' \
.format(pol.placemark.id)
except ValueError:
kml.newpoint(name=place,
description=infowindow,
coords=[(longitude, latitude)])
self.stdout.write(str(absMagnitude))
earthquakeNumber += 1
playlist.newgxwait(gxduration=3 * balloonDuration)
fileName = "lastWeekEarthquakes.kmz"
currentDir = os.getcwd()
dir1 = os.path.join(currentDir, "static/demos")
dirPath2 = os.path.join(dir1, fileName)
self.stdout.write("Saving kml: " + str(dirPath2))
if os.path.exists(dirPath2):
os.remove(dirPath2)
kml.savekmz(dirPath2, format=False)
