def main():
sm = StaticMap()
im = Image.open(urlopen(sm.get()))
im = im.convert('RGB')
w, h = im.size[0], im.size[1] - 22 # remove Google footer
im = im.crop([0, 0, w, h])
arr = asarray(im)
char_array = [['' for i in range(w)] for j in range(h)]
found_start = False
known_markers = [(31, 60, 19), (44, 35, 17), (0, 0, 0)]
for i in range(w):
for j in range(h):
_col = tuple(arr[j, i])
_char = col_to_char(_col)
if _col[0] < 60 and _col[1] < 60 and _col[2] < 60:
print("Mark found!")
if found_start:
_char = 'B'
else:
_char = 'A'
found_start = True
char_array[j][i] = _char
with open(sm.name(), 'wb') as cmap:
for line in char_array:
for c in line:
cmap.write(c.encode())
cmap.write('\r\n'.encode())
def make_map(filename_without_ext,
addresses,
gmic_effect="fx_freaky_bw 90,20,0,0,0,0",
no_display=False,
prefix="LETTER"):
m = StaticMap(800, 600, 80)
g = gmic.Gmic("update")
locator = Nominatim(user_agent="BerlinWallBreaker Agent")
print("geocoding..")
for address in addresses:
loc = locator.geocode(address)
icon_flag = IconMarker((loc.longitude, loc.latitude),
'./samples/icon-flag.png', 12, 32)
m.add_marker(icon_flag)
print(loc)
image = m.render()
output_filename1 = prefix + filename_without_ext + "_original.png"
output_filename2 = prefix + filename_without_ext + ".png"
image.save(output_filename1)
print(output_filename1)
if not no_display:
g.run(output_filename1 + " display")
if "_fx_stylize" in gmic_effect:
gmic.run(output_filename1 + " " + gmic_effect + " output[2] " +
output_filename2 + (" display[2]" if not no_display else ""))
else:
gmic.run(output_filename1 + " " + gmic_effect + " output " +
output_filename2 + (" display" if not no_display else ""))
print(output_filename2)
return output_filename1, output_filename2
def dijkstra_route(G, position):
m = StaticMap(400, 500)
last = int(-1)
time = int(0)
path = nx.dijkstra_path(G, -1, 0)
# We go through each node in the minimum path between the start and end.
for i in path:
if (i != -1):
coord1 = swap(position[last])
coord2 = swap(position[i])
e = (last, i)
time += G.get_edge_data(*e)['weight']
if i == path[1] or i == 0:
# Walking -> green edge (first or last edge).
m.add_line(Line((coord1, coord2), 'green', 2))
else:
# Riding a Bicycle -> blue edge.
m.add_line(Line((coord1, coord2), 'blue', 2))
# Origin and destination points are purple and bigger.
if (i > 0):
m.add_marker(CircleMarker(swap(position[i]), 'red', 2))
else:
m.add_marker(CircleMarker(swap(position[i]), 'purple', 4))
last = i
return m, int(time)
def plotpop(self, lat, lon, dist):
'''
Returns the plot of the graph of the cities that have distance
lower than dist from (lat, lon)
'''
mapa = StaticMap(400, 400)
some = False
max_pop = 0
for node in self.G.nodes:
if self.is_plottable((node, node), (lat, lon), dist):
some = True
if max_pop < self.populations[node]:
max_pop = self.populations[node]
if not some:
return
for node in self.G.nodes:
if self.is_plottable((node, node), (lat, lon), dist):
rev_coords = tuple(reversed(self.coordinates[node]))
circle = CircleMarker(
rev_coords, 'red',
self.populations[node] * c.CIRCLE_SCALE / max_pop)
mapa.add_marker(circle)
image = mapa.render()
bio = BytesIO()
bio.name = 'map.png'
image.save(bio)
bio.seek(0)
return bio
def render_single_tile(m: StaticMap, ext: list) -> Image:
"""
Revised version of StaticMap.render() allows explicit extent + empty maps
Args:
m: Static map object for rendering
ext: the map extent in (min_lon, min_lat, max_lon, max_lat)
Returns:
The returned RGB image as an PIL.Image
"""
ex_poly = [[ext[0], ext[1]],
[ext[0], ext[3]],
[ext[2], ext[1]],
[ext[2], ext[3]]]
polygon = Polygon(ex_poly, 'white', 'white', True)
m.add_polygon(polygon)
m.zoom = m._calculate_zoom()
# get extent of all lines
extent = ext
# calculate center point of map
lon_center, lat_center = (extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2
m.x_center = _lon_to_x(lon_center, m.zoom)
m.y_center = _lat_to_y(lat_center, m.zoom)
image = Image.new('RGB', (m.width, m.height), m.background_color)
m._draw_base_layer(image)
m.polygons.remove(polygon)
m._draw_features(image)
return image
def plotgraph(self, lat, lon, dist):
'''
Returns the plot of the graph of the edges between cities that
have distance than dist from (lat, lon)
'''
mapa = StaticMap(400, 400)
some = False
for edge in self.G.edges:
if self.is_plottable(edge, (lat, lon), dist):
some = True
# Staticmap needs coordinates in order (Longitude, Latitude)
rev_coords_0 = tuple(reversed(self.coordinates[edge[0]]))
rev_coords_1 = tuple(reversed(self.coordinates[edge[1]]))
mapa.add_line(Line((rev_coords_0, rev_coords_1), 'blue', 3))
if not some:
return
image = mapa.render()
bio = BytesIO()
bio.name = 'map.png'
image.save(bio)
bio.seek(0)
return bio
def paintMapPop(self):
m = StaticMap(2000,1500,20)
for n in self.subgraph.nodes:
point = (float(self.lista[int(n)][6]),float(self.lista[int(n)][5]))
pob = float(self.lista[int(n)][4])
tam = int(pob/100000)+1
m.add_marker(CircleMarker(point,'red',tam))
image = m.render()
image.save("pop.png")
def draw_map_plotpop(graph, dist, lat, lon):
fitxer = "%d.png" % random.randint(1000000, 9999999)
reduced_graph = graphs.get_graph_dist_lat_lon(graph, dist, lat, lon)
mapa = StaticMap(500, 500)
for node in reduced_graph:
mapa.add_marker(
CircleMarker(node.lon_lat(), 'blue', node.population / 1000000))
imatge = mapa.render()
imatge.save(fitxer)
return fitxer
def getRSSIMax():
""" fonction who search in the DB the best signal reception and despaly it in the map"""
m = StaticMap(largeur,
hauteur,
url_template='http://a.tile.osm.org/{z}/{x}/{y}.png')
cursor.execute("""SELECT max(RSSI) FROM coord """)
rssi = cursor.fetchone()
print rssi
cursor.execute(
"""SELECT e_lat, e_long, s_lat, s_long, distance, SNR FROM coord WHERE RSSI=?""",
rssi)
coord = cursor.fetchone() #getGPS()
print coord
lat_E, long_E, lat_S, long_S = coord[0], coord[1], coord[2], coord[3]
m.add_line(Line(((long_S, lat_S), (long_E, lat_E)), 'blue', 3))
icon_flag_1 = IconMarker((long_E, lat_E), 'icon/icon-flag.png', 12, 32)
m.add_marker(icon_flag_1)
icon_flag_2 = IconMarker((long_S, lat_S), 'icon/icon-flag.png', 12, 32)
m.add_marker(icon_flag_2)
global image
image = m.render()
image.save('map/RSSIMaxMap.png')
image = PhotoImage(file='map/RSSIMaxMap.png')
canvas.create_image(0, 0, image=image, anchor=NW)
latLabel.configure(text=coord[0])
longLabel.configure(text=coord[1])
distenceLabel.configure(text=coord[4])
rssiLabel.configure(text=coord[4])
snrLabel.configure(text=coord[5])
def makemap(lat, lon, id):
map = StaticMap(args.mapwidth,
args.mapheight,
80,
url_template='http://a.tile.osm.org/{z}/{x}/{y}.png')
marker = IconMarker((lon, lat), 'utils/images/icon-flag.png', 12, 32)
map.add_marker(marker)
image = map.render(zoom=15)
image.save('utils/images/geocoded/{}.png'.format(id))
log.info("Generated and saved {}.png".format(id))
return
def get(self, scenario):
project = request.args.get('project')
if project is None:
config = current_app.cea_config
else:
if not os.path.exists(project):
abort(400, 'Project path: "{project}" does not exist'.format(project=project))
config = cea.config.Configuration()
config.project = project
choices = list_scenario_names_for_project(config)
if scenario in choices:
locator = cea.inputlocator.InputLocator(os.path.join(config.project, scenario))
zone_path = locator.get_zone_geometry()
if os.path.isfile(zone_path):
cache_path = os.path.join(config.project, '.cache')
image_path = os.path.join(cache_path, scenario + '.png')
zone_modified = os.path.getmtime(zone_path)
if not os.path.isfile(image_path):
image_modified = 0
else:
image_modified = os.path.getmtime(image_path)
if zone_modified > image_modified:
# Make sure .cache folder exists
if not os.path.exists(cache_path):
os.makedirs(cache_path)
try:
zone_df = geopandas.read_file(zone_path)
zone_df = zone_df.to_crs(get_geographic_coordinate_system())
polygons = zone_df['geometry']
polygons = [list(polygons.geometry.exterior[row_id].coords) for row_id in range(polygons.shape[0])]
m = StaticMap(256, 160)
for polygon in polygons:
out = Polygon(polygon, 'blue', 'black', False)
m.add_polygon(out)
image = m.render()
image.save(image_path)
except Exception as e:
abort(400, str(e))
import base64
with open(image_path, 'rb') as imgFile:
image = base64.b64encode(imgFile.read())
return {'image': image.decode("utf-8")}
abort(400, 'Zone file not found')
else:
abort(400, 'Scenario does not exist', choices=choices)
def drawPop(dist, lat, lon, graph):
m = StaticMap(400, 400)
returned = nodesAtDistFrom(dist, lat, lon, graph)
G = returned[0]
maxPop = returned[1]
for node in list(G.nodes):
m.add_marker(
CircleMarker(
(G.nodes[node]['longitude'], G.nodes[node]['latitude']), 'red',
max(3, G.nodes[node]['pop'] * 15 / maxPop)))
image = m.render()
image.save('plotpop.png')
def render_image(self):
self.static_map = StaticMap(
700, 700) #, url_template='http://a.tile.osm.org/{z}/{x}/{y}.png')
self.drone_marker = CircleMarker(self.map_coordinates, '#0036FF', 12)
self.static_map.add_marker(self.drone_marker)
for stationary_obstacle in self.stationary_obstacles:
self.static_map.add_marker(stationary_obstacle)
for moving_obstacle in self.moving_obstacles:
self.static_map.add_marker(moving_obstacle)
self.image = self.static_map.render(zoom=17)
self.image.save('map.png')
def where(update, context):
try:
lat, lon = update.message.location.latitude, update.message.location.longitude
fitxer = "%d.png" % random.randint(1000000, 9999999)
mapa = StaticMap(500, 500)
mapa.add_marker(CircleMarker((lon, lat), 'blue', 10))
imatge = mapa.render()
imatge.save(fitxer)
context.bot.send_photo(chat_id=update.effective_chat.id,
photo=open(fitxer, 'rb'))
os.remove(fitxer)
except Exception as e:
print(e)
context.bot.send_message(chat_id=update.effective_chat.id, text='💣')
async def get_map(self):
covering = await self.level_10_covering()
cells = [S2_L10(self.bot, x) for x in covering]
approx_width = sqrt(len(cells))
px_dim = 100 * ceil(approx_width)
lines = []
for x in cells:
lines.extend(x.get_border())
url_template = 'https://a.basemaps.cartocdn.com/rastertiles/voyager_nolabels/{z}/{x}/{y}.png'
m = StaticMap(px_dim, ceil(px_dim * 1.2), 5, ceil(px_dim / 10),
url_template)
for l in lines:
m.add_line(l)
return m, cells
def create_map(coords, filename):
image_width = 1200
image_height = 630
m = StaticMap(width=image_width,
height=image_height,
url_template="http://tile.stamen.com/toner/{z}/{x}/{y}.png")
marker = IconMarker(coords, './location-marker.png', 18, 30)
m.add_marker(marker)
image = m.render()
image.save(filename + '.png')
return filename + '.png'
def plotpop(g, dist, lat, lon):
# crear mapa i setejar visibilitat
mapa = StaticMap(500, 500)
g = setVisibilityNodes(g, dist, lat, lon)
# afegir markers
mapa = paintNodes(g, mapa, True)
# crear imatge
try:
img = mapa.render()
except:
raise MyExceptions.MapRenderException
return img
def print_path(path, G, file):
m = StaticMap(800, 800)
# go through the path and print every node
for i in range(len(path) - 1):
marker = CircleMarker(path[i], 'red', 6)
m.add_marker(marker)
coordinates = [path[i], path[i + 1]]
line = Line(coordinates, 'blue', 1)
m.add_line(line)
marker = CircleMarker(path[len(path) - 1], 'red', 6)
m.add_marker(marker)
image = m.render()
image.save(file)
def dibujarPlotpop(distancia, lat, lon):
myMap = StaticMap(600, 600)
tam = 3
listaC = listaCercanos(distancia, lat, lon)
global matrizBloques
for x in listaC:
for y in matrizBloques[x[1]][x[0]]:
latAux = grafo.node[y]['latitude']
lonAux = grafo.node[y]['longitude']
dist = calcularDistKm(lat, lon, latAux, lonAux)
if dist < distancia:
marker = CircleMarker(
(lonAux, latAux), 'red',
math.ceil(grafo.node[y]['population'] / (30000 * tam)) + 1)
myMap.add_marker(marker)
image = myMap.render()
image.save('plotpop.png')
def setUpClass(cls) -> None:
cls.m = StaticMap(IMG_WIDTH,
IMG_HEIGHT,
url_template=tile_server_dns_noport.replace(
'{p}', str(tile_server_ports[0])))
cls.center = [36.1070, 36.7855]
cls.s = generate_static_maps(tile_server_dns_noport, tile_server_ports)
cls.ext = build_tile_extent(cls.center, radius_in_meters=50)
def draw_map():
m = StaticMap(4000, 4000)
for key, access_point in access_point_data.items():
if not ('lat' in access_point and 'lng' in access_point):
continue
coords = (access_point['lat'], access_point['lng'])
if access_point['lng'] - -34.611944444444 > 0.1:
continue
if access_point['lat'] - -58.364722222222 > 0.1:
continue
colors = {
'open': 'red',
'wep': 'red',
'wpa': 'yellow',
'wpa2': 'green'
}
marker_outline = CircleMarker(coords,
colors[access_point['encryption']], 18)
marker = CircleMarker(coords, colors[access_point['encryption']], 12)
m.add_marker(marker_outline)
m.add_marker(marker)
image = m.render(zoom=15)
temp_file = NamedTemporaryFile(suffix='.png')
image.save(temp_file.name)
image.save('/home/lcubo/test1.png')
return temp_file
def route(self, src, dst):
'''
Returns the plot of the shortest route between src and dst
'''
real_src = self.get_most_similar(src)
real_dst = self.get_most_similar(dst)
if real_src and real_dst:
try:
path = nx.algorithms.shortest_paths.generic.shortest_path(
self.G, source=real_src, target=real_dst, weight='weight')
except Exception as e:
return c.PATH_FAIL
mapa = StaticMap(400, 400)
for cities in zip([''] + path, path):
rev_coords_1 = tuple(reversed(self.coordinates[cities[1]]))
circle = CircleMarker(rev_coords_1, 'red', 4)
mapa.add_marker(circle)
if '' in cities:
continue
rev_coords_0 = tuple(reversed(self.coordinates[cities[0]]))
mapa.add_line(Line((rev_coords_0, rev_coords_1), 'blue', 3))
image = mapa.render()
bio = BytesIO()
bio.name = 'map.png'
image.save(bio)
bio.seek(0)
return bio
if not real_src:
return c.SOURCE_FAIL
return c.DEST_FAIL
def draw_map_route(graph, src, dst):
fitxer = "%d.png" % random.randint(1000000, 9999999)
route_node_list = graphs.get_graph_route(graph, src, dst)
mapa = StaticMap(500, 500)
mapa.add_marker(CircleMarker(route_node_list[0].lon_lat(), 'blue', 5))
for i in range(len(route_node_list) - 1):
mapa.add_marker(
CircleMarker(route_node_list[i + 1].lon_lat(), 'blue', 5))
mapa.add_line(
Line((route_node_list[i].lon_lat(),
route_node_list[i + 1].lon_lat()), 'blue', 1))
imatge = mapa.render()
imatge.save(fitxer)
return fitxer
def plotgraph(G, name_file):
map = StaticMap(750, 750)
for station in G.edges:
coord1, coord2 = station[0], station[1]
line = Line([[coord1.lon, coord1.lat], [coord2.lon, coord2.lat]],
'#0000FFBB', 2)
map.add_line(line)
for station in G.nodes:
marker = CircleMarker([station.lon, station.lat], 'red', 4)
marker_outline = CircleMarker([station.lon, station.lat], 'black', 8)
map.add_marker(marker_outline)
map.add_marker(marker)
image = map.render()
image.save(name_file)
def route_get_images(scenario):
cea_config = current_app.cea_config
project_path = cea_config.project
locator = cea.inputlocator.InputLocator(
os.path.join(project_path, scenario))
zone_path = locator.get_zone_geometry()
if not os.path.isfile(zone_path):
abort(404, 'Zone file not found')
cache_path = os.path.join(project_path, '.cache')
image_path = os.path.join(cache_path, scenario + '.png')
zone_modified = os.path.getmtime(zone_path)
if not os.path.isfile(image_path):
image_modified = 0
else:
image_modified = os.path.getmtime(image_path)
if zone_modified > image_modified:
# Make sure .cache folder exists
if not os.path.exists(cache_path):
os.makedirs(cache_path)
zone_df = geopandas.read_file(zone_path)
zone_df = zone_df.to_crs(get_geographic_coordinate_system())
polygons = zone_df['geometry']
polygons = [
list(polygons.geometry.exterior[row_id].coords)
for row_id in range(polygons.shape[0])
]
m = StaticMap(256, 160)
for polygon in polygons:
out = Polygon(polygon, 'blue', 'black', False)
m.add_polygon(out)
image = m.render()
image.save(image_path)
import base64
with open(image_path, 'rb') as imgFile:
image = base64.b64encode(imgFile.read())
return image
def render_map(map_: StaticMap,
retry=True) -> t.Optional[Image.Image]: # no test coverage
try:
img = map_.render()
except Exception:
if retry:
return render_map(map_, retry=False)
log.error("Error rendering map", exc_info=True)
img = None
return img
def global_data():
""" fonction who search in the DB the distance reached by the the signal"""
m = StaticMap(largeur,
hauteur,
url_template='http://b.tile.osm.org/{z}/{x}/{y}.png')
cursor.execute("SELECT e_lat, e_long FROM coord")
rows = cursor.fetchall()
for row in rows:
print row
icon_flag = IconMarker((row[1], row[0]), 'icon/icon-flag.png', 12, 32)
m.add_marker(icon_flag)
global image
image = m.render()
image.save('map/GlobalMap.png')
image = PhotoImage(file='map/GlobalMap.png')
canvas.create_image(0, 0, image=image, anchor=NW)
class OsmStaticMapPlotter(Plotter):
def __init__(self, width=2000, height=1500):
Plotter.__init__(self)
self.static_map_ = StaticMap(
width,
height,
url_template="http://a.tile.osm.org/{z}/{x}/{y}.png")
def DrawLine(self, src_gps, dst_gps, color, width):
self.static_map_.add_line(
Line(((src_gps[1], src_gps[0]), (dst_gps[1], dst_gps[0])), color,
width))
def DrawPoint(self, node_gps, color, size):
self.static_map_.add_marker(
CircleMarker((node_gps[1], node_gps[0]), color, size))
def SaveMap(self, map_filename):
image = self.static_map_.render()
image.save(map_filename)
def drawRoute(G, path):
m = StaticMap(400, 400)
m.add_marker(
CircleMarker(
(G.nodes[path[0]]['longitude'], G.nodes[path[0]]['latitude']),
'red', 3))
for i in range(len(path) - 1):
m.add_marker(
CircleMarker((G.nodes[path[i + 1]]['longitude'],
G.nodes[path[i + 1]]['latitude']), 'red', 3))
m.add_line(
Line(
((G.nodes[path[i]]['longitude'], G.nodes[path[i]]['latitude']),
(G.nodes[path[i + 1]]['longitude'],
G.nodes[path[i + 1]]['latitude'])), 'blue', 1))
image = m.render()
image.save('plotroute.png')
def generate_static_maps(url_port_template: str, ports: List[int]) -> List[StaticMap]:
"""
Small utility function for generating multiple StaticMaps
Args:
url_port_template: The url_template but with an additional parameter {p} for the port
ports: List of port numbers for the StaticMap objects
Returns:
List of StaticMaps object initialized with the correct url_templates
"""
return [StaticMap(im_width, im_height, url_template=url_port_template.format(p=p, z='{z}', x='{x}', y='{y}'))
for p in ports]
import csv
import random
from staticmap import StaticMap, CircleMarker
m = StaticMap(1000, 900, url_template='http://a.tile.stamen.com/toner/{z}/{x}/{y}.png')
with open('data/crimes-robbery.csv') as csvfile:
reader = csv.reader(csvfile, delimiter=';')
for row in reader:
marker = CircleMarker((float(row[1]), float(row[0])), (232, 152, 16, 180), 6)
m.add_marker(marker)
image = m.render(center=[-87.684871189, 41.8348221989])
image.save('robbery.png')
from staticmap import StaticMap
from boundary import Boundary, Range, LatLon
import pickle
import pprint
import glob
from fileio import Fileio
x_range = Range(-87.69215,-87.634896)
y_range = Range(41.858952,41.886565)
boundary = Boundary(x_range, y_range)
center = boundary.center()
center_latlon = LatLon(lon=center[0], lat=center[1])
print StaticMap.latlon2xy_tile(center_latlon.lat, center_latlon.lon, 12)
print center_latlon
metainfo = StaticMap.get_map("chicago.png", \
center={'lat':center_latlon.lat, 'lon':center_latlon.lon}, \
zoom=14, scale=2, maptype="roadmap")
pprint.pprint(metainfo)
print StaticMap.xy2latlon(metainfo, 0, 0)
print StaticMap.latlon2xy_centered(metainfo, center_latlon.lat, center_latlon.lon)
ll = metainfo['bbox']['low_left']
ur = metainfo['bbox']['upper_right']
def testLat(self):
for lat in range(-89, 89, 2):
for zoom in range(0, 10):
y = StaticMap._lat_to_y(lat, zoom)
l = StaticMap._y_to_lat(y, zoom)
self.assertAlmostEqual(lat, l, places=5)
def testLon(self):
for lon in range(-180, 180, 20):
for zoom in range(0, 10):
x = StaticMap._lon_to_x(lon, zoom)
l = StaticMap._x_to_lon(x, zoom)
self.assertAlmostEqual(lon, l, places=5)
def update_geometry(self, configuration_code, force_update=False):
"""
Update the geometry of a questionnaire based on the GeoJSON found in the
data json.
Args:
configuration_code:
Returns:
-
"""
def get_geometry_from_string(geometry_string):
"""
Extract and convert the geometry from a (GeoJSON) string.
Args:
geometry_string: The geometry as (GeoJSON) string.
Returns:
A GeometryCollection or None.
"""
if geometry_string is None:
return None
try:
geometry_json = json.loads(geometry_string)
except json.decoder.JSONDecodeError:
return None
geoms = []
for feature in geometry_json.get('features', []):
try:
feature_geom = GEOSGeometry(
json.dumps(feature.get('geometry')))
except ValueError:
continue
except GDALException:
continue
geoms.append(feature_geom)
if geoms:
return GeometryCollection(tuple(geoms))
else:
return None
geometry_value = self.configuration_object.get_questionnaire_geometry(self.data)
geometry = get_geometry_from_string(geometry_value)
geometry_changed = self.geom != geometry
try:
self.geom = geometry
self.save()
except ValidationError:
return
if self.geom is None or (not force_update and not geometry_changed):
# If there is no geometry or if it did not change, there is no need
# to create the static map image (again)
return
# Create static map
width = 1000
height = 800
marker_diameter = 24
marker_color = '#0036FF'
m = StaticMap(width, height)
for point in iter(self.geom):
m.add_marker(CircleMarker((point.x, point.y), marker_color, marker_diameter))
bbox = None
questionnaire_country = self.get_question_data('qg_location', 'country')
if len(questionnaire_country) == 1:
country_iso3 = questionnaire_country[0].replace('country_', '')
country_iso2 = settings.CONFIGURATION_COUNTRY_ISO_MAPPING.get(
country_iso3)
if country_iso2:
r = requests.get(
'http://api.geonames.org/countryInfoJSON?username=wocat_webdev&country={}'.format(
country_iso2))
geonames_country = r.json().get('geonames')
if len(geonames_country) == 1:
ctry = geonames_country[0]
poly_coords = [
[ctry.get('west'), ctry.get('north')],
[ctry.get('west'), ctry.get('south')],
[ctry.get('east'), ctry.get('south')],
[ctry.get('east'), ctry.get('north')],
[ctry.get('west'), ctry.get('north')]
]
bbox = Polygon(poly_coords, None, None)
if bbox:
m.add_polygon(bbox)
image = m.render()
else:
# No bbox found, guess zoom level
image = m.render(zoom=6)
map_folder = get_upload_folder_path(str(self.uuid), subfolder='maps')
if not os.path.exists(map_folder):
os.makedirs(map_folder)
filename = '{}_{}.jpg'.format(self.uuid, self.version)
image.save(os.path.join(map_folder, filename))
'height':600, \
'filename': 'new_york.png', \
'markers': [{'lat': 40.714728, 'lon':-73.998672, 'filename': 'accident.png', 'offset_x': -16, 'offset_y': 0}], \
'paths': ( ({'lat': 40.714728, 'lon': -73.998672}, {'lat': 40.714728, 'lon': -73.80234}) ) \
},\
{ 'lat': 27.790491, \
'lon':-81.584473, \
'zoom':7, \
'width':600, \
'height':600, \
'filename': 'florida.png', \
'markers': [{'lat': 27.790491, 'lon':-81.584473, 'filename': 'accident.png', 'offset_x': 0, 'offset_y': 0}],
'paths': () \
}]
output_dir = 'tests'
my_map = StaticMap()
for test_map in maps:
print "Generating... " + test_map['filename']
my_map.setup_map(lat = test_map['lat'], lon = test_map['lon'], zoom = test_map['zoom'], map_width = test_map['width'], map_height = test_map['height'])
for path in test_map['paths']:
my_map.add_path({'lat': 40.714728, 'lon': -73.998672}, {'lat': 40.924728, 'lon': -73.98234})
for marker in test_map['markers']:
my_map.add_marker(marker)
my_map.save_map(output_dir + '/' + test_map['filename'])
print "Generated"
my_map.reset()
import csv
import random
from staticmap import StaticMap, CircleMarker
m = StaticMap(1000, 900, url_template='http://a.tile.stamen.com/toner/{z}/{x}/{y}.png')
def label_to_color(label):
alpha = 180
return {
'good': (0,153,102,alpha),
'moderate': (255,222,51,alpha),
'unhealthy for sensitive': (255,153,51,alpha),
'unhealthy': (204,0,51,alpha),
'very unhealthy': (102,0,153,alpha),
'hazardous': (126,0,35,alpha)
}[label]
with open('data/airVis.csv') as csvfile:
reader = csv.reader(csvfile, delimiter=';')
for row in reader:
marker = CircleMarker((float(row[1]), float(row[0])), label_to_color(row[2]), 6)
m.add_marker(marker)
image = m.render(zoom=6, center=[15.2793976568, 50.5197351804])
image.save('marker-k3-minkowski.png')
random.random
