def avoidRoute(lon, lat, lon2, lat2, profile):
buffer = []
#Seting the route coordinates
coordinates = [[lon, lat], [lon2, lat2]]
#Open Route Service credentials
api_key = '5b3ce3597851110001cf62480bce1c9f6f5041d0ae79d1a8847f8b98'
clnt = client.Client(key=api_key)
#Makes a request to get the traffic information
get_feature_collection = "http://127.0.0.1:5000/traffic-information"
feature_collection_req = requests.get(url=get_feature_collection)
feature_collection = feature_collection_req.json()
#Adding buffers
for geom in feature_collection['features']:
route_buffer = LineString(geom['geometry']['coordinates']).buffer(
0.0005) # Create geometry buffer
simp_geom = route_buffer.simplify(0.00005) # Simplify geometry
buffer.append(simp_geom)
#Merging the buffer geometries in case there are 2 or more polygons next to each other
union_buffer = cascaded_union(buffer)
avoid_request = {
'coordinates': coordinates,
'format_out': 'geojson',
'profile': profile,
'preference': 'shortest',
'instructions': False,
'options': {
'avoid_polygons': mapping(union_buffer)
}
}
avoid_route = clnt.directions(**avoid_request)
return avoid_route
def calc_distance_matrix(marker_coords):
ors_clnt = client.Client(key=app.config['ORS_KEY'])
request = {'locations': marker_coords,
'profile': 'foot-walking',
'metrics': ['duration']}
dist_matrix = ors_clnt.distance_matrix(**request)
return dist_matrix
def get_distance_matrix_response(marker_coords):
ors_clnt = client.Client(key=get_instance_settings().ors_key)
request = {
'locations': marker_coords,
'profile': 'foot-walking',
'metrics': ['duration']
}
dist_matrix_response = ors_clnt.distance_matrix(**request)
return dist_matrix_response
def __init__(self, GoogleAPIKey=None, OpenAPIKey=None, prefferedDistanceMatrix="Open"):
self.GoogleAPIKey = GoogleAPIKey
self.OpenAPIKey = OpenAPIKey
self.GoogleClient = gclient(key=self.GoogleAPIKey)
self.OpenRouteClient = orclient.Client(key=self.OpenAPIKey)
if prefferedDistanceMatrix != "Open" and prefferedDistanceMatrix != "Google":
raise ValueError("prefferedDistanceMatrix should be \"Open\" or \"Google\"")
elif prefferedDistanceMatrix == "Open":
self.DistanceMatrix = self.__OpenDistanceMatrix
elif prefferedDistanceMatrix == "Google":
self.DistanceMatrix = self.__GoogleDistanceMatrix
def directions_route_duration(route_coords):
ors_clnt = client.Client(key=app.config['ORS_KEY'])
request = {'coordinates': route_coords,
'profile': 'foot-walking',
'geometry': 'true',
'format_out': 'geojson',
}
route = ors_clnt.directions(**request)
# duration in minutes
duration = route['features'][0]['properties']['summary'][0]['duration'] / 60
return route, duration
def iso_request(self, amenities, city_border):
"""Openrouteservice isochrone calculation"""
print('Make sure to first build correct ORS graph! E.g. normal graph for normal isochrone request. \n'
'Requesting isochrones...')
# using local openrouteservice package with the manually created routing graph
clnt = client.Client(base_url='http://localhost:8080/ors', key=self.api_key)
# osm data id = id_1; hot data id = osm_id
id_name = ['id_1' if 'id_1' in amenities else 'osm_id'][0]
iso_range_values = SETTINGS['iso_range_values']
request_counter = 0
iso_df_list = []
for geom, amenity_type, amenity_id in zip(amenities['geometry'], amenities['amenity'], amenities[id_name]):
point_geom = mapping(geom)
# isochrone parameters
params_iso = {'locations': [[point_geom['coordinates'][0], point_geom['coordinates'][1]]],
'profile': 'driving-car',
'interval': iso_range_values[0],
'range': [iso_range_values[-1]]}
try:
# request isochrones
iso_df = pd.DataFrame.from_dict(clnt.isochrones(**params_iso)['features'])
# adjust geometry column for geopandas dataframe
iso_df['geometry'] = [Polygon(g['coordinates'][0]) for g in iso_df['geometry']]
# add additional data
iso_df['value'] = [g['value'] for g in iso_df['properties']]
iso_df['amenity'] = amenity_type
iso_df['iso_id'] = request_counter
iso_df['amenity_id'] = amenity_id
iso_df_list.append(iso_df)
except exceptions.ApiError:
print(params_iso, 'is isolated and out of routing graph range.')
pass
request_counter += 1
print('Requested isochrones for %s healthsite locations from ORS API' % request_counter)
all_isochrones = pd.concat([layer for layer in iso_df_list])
all_isochrones = gpd.GeoDataFrame(all_isochrones, geometry='geometry')
return all_isochrones
def requestRoute(lon, lat, lon2, lat2, profile):
#Open Route Service credentials
api_key = '5b3ce3597851110001cf62480bce1c9f6f5041d0ae79d1a8847f8b98'
clnt = client.Client(key=api_key)
#Seting the route coordinates
coordinates = [[lon, lat], [lon2, lat2]]
#Defines the route parameters
direction_params = {
'coordinates': coordinates,
'profile': profile,
'format_out': 'geojson',
'preference': 'shortest',
'instructions': False,
'geometry': 'true'
}
#Makes a request to Open Route Service to get the route
regular_route = clnt.directions(**direction_params)
return regular_route
def index():
buffer = []
api_key = '5b3ce3597851110001cf62480bce1c9f6f5041d0ae79d1a8847f8b98' #https://openrouteservice.org/sign-up
clnt = client.Client(key=api_key)
map = folium.Map(
tiles=
'https://maps.heigit.org/openmapsurfer/tiles/roads/webmercator/{z}/{x}/{y}.png',
attr=
'Map data (c) OpenStreetMap, Tiles (c) <a href="https://heigit.org">GIScience Heidelberg</a>',
location=([55.71459, 12.577]),
zoom_start=7) # Create map
#Adding traffic information
trafficUrl = "http://127.0.0.1:5000/traffic-information"
req = requests.get(url=trafficUrl)
traffic = req.json()
#Styles the traffic information layer
style_function = lambda x: {
'color': 'red',
}
#Adds geoJson to the map
folium.GeoJson(traffic, style_function=style_function).add_to(map)
#Add route to the map
routeUrl = "http://127.0.0.1:5000/request-route&start=12.624406814575197,55.664079718036724;&end=12.458496093750002,55.69422894298507;&profile=driving-car"
routeReq = requests.get(url=routeUrl)
route = routeReq.json()
#Styles route
style_route = lambda x: {
'color': 'green',
}
map.add_child(folium.map.LayerControl())
return map._repr_html_()
import json
import folium
from openrouteservice import client, places, directions, distance_matrix
from geopy.geocoders import Nominatim
from statistics import median
# api key for openrouteservice (which will figure out the optimal route)
api_key = '5b3ce3597851110001cf62484c5ca3f76ff944dfa2d23b773efec8d7'
clnt = client.Client(key=api_key)
geolocator = Nominatim(user_agent='Meals On Wheels Route')
locs_addresses = [
'64 pine street milford ma', '122 west spruce street milford ma',
'8 della street milford ma', '14 lawrence street milford ma',
'17 lawrence street milford ma', '59 lawrence street milford ma',
'6 iadarola avenue milford ma', '36 highland street milford ma',
'21 harding street milford ma', '8 western ave milford ma',
'17 deluca rd milford ma', '3 prospect heights milford ma',
'6 prospect heights milford ma', '34 prospect heights milford ma',
' 87 prospect heights milford ma'
]
locs_coords = []
latitudes = []
longitudes = []
# convert above addresses to coordinates using geopy
for loc in locs_addresses:
curr = geolocator.geocode(loc)
# print(curr.address)
locs_coords.append((curr.longitude, curr.latitude))
import json
import copy
import logging
import time
from openrouteservice import client
from itertools import groupby
import objectparams as opms
import transportmeans as trmns
import osm2geojson as o2g
logger = logging.getLogger('locationsearch')
opr_api_key = '' # put here your openrouteservice api key
opr_client = client.Client(key=opr_api_key)
timeout = 180
def process_request(payload):
coords = payload['coords']
main_object = payload['mainObject']
relative_object = payload['relativeObject']
poly_coords = None
query = ""
request_begin = time.time()
# search considering time reach distance
def update_map(n_clicks, add_start, add_end):
if any([add_end is None, add_start is None]):
pass
else:
# 1. Reverse-geocoding (i.e finding geo coordinates from addresses)
geocod_start = geocoder.osm(add_start)
geocod_end = geocoder.osm(add_end)
# 2. Compute the box to look for POI around
box = [(geocod_start.lat, geocod_end.lng),
(geocod_end.lat, geocod_end.lng),
(geocod_end.lat, geocod_start.lng),
(geocod_start.lat, geocod_start.lng)]
poly_box = Polygon(box)
poly_box = poly_box.buffer(0.0025).simplify(0.05)
# 3. Retrieve the POI in the area
api = overpy.Overpass()
result_nodes = api.query(
"(node['shop']{0};node['amenity']{0};);out;".format(
str(poly_box.exterior.bounds)))
result_areas = api.query(
"(area['shop']{0};area['amenity']{0};);out;".format(
str(poly_box.exterior.bounds)))
# 4. Filter the POI in the box to keep only the points to be avoid
# Loading the csv for the danger levels
dang_list = pd.read_csv(
'C:/Users/daphn/Documents/EUvsVirus/hackathon_exchange/DangerScoreList.csv',
delimiter=',')
# Score the POI in the area
nodes_score = add_score(
dang_list, result_nodes
) # nodes_score is a list of overpy objects, with lat and lon info,
dangers_poly = [] # sites_poly
# I define dangerous a POI with score greater than 1
for node in nodes_score:
if node.tags['dangerscore'] != '1':
lat = node.lat
lon = node.lon
dangers_poly_coords = Point(lon,
lat).buffer(0.0002).simplify(0.05)
dangers_poly.append(dangers_poly_coords)
danger_buffer_poly = [
] # site_buffer_poly, which is the input for the avoid polygon option
for danger_poly in dangers_poly:
poly = Polygon(danger_poly)
danger_buffer_poly.append(poly)
# 5.Request the route
route_request = {
'coordinates': [[geocod_start.lng, geocod_start.lat],
[geocod_end.lng, geocod_end.lat]],
# Careful long then lat and not lat then long
'format_out':
'geojson',
'profile':
'foot-walking',
'preference':
'shortest',
'instructions':
False,
'options': {
'avoid_polygons': mapping(MultiPolygon(danger_buffer_poly))
}
}
api_key = '5b3ce3597851110001cf6248d14c60f017174b11b170ff63fdbf48b3'
clnt = client.Client(key=api_key)
route_directions = clnt.directions(**route_request)
# 6.Display the route and the dangerous points
# Create the base map
map = folium.Map(tiles='Stamen Toner',
location=([geocod_start.lat, geocod_start.lng]),
zoom_start=14) # Create map
# Beginning and end markers
folium.Marker([geocod_start.lat, geocod_start.lng],
popup='<i>Start</i>').add_to(map)
folium.Marker([geocod_end.lat, geocod_end.lng],
popup='<i>End</i>').add_to(map)
# Plotting the dangerous areas
folium.features.GeoJson(data=mapping(MultiPolygon(danger_buffer_poly)),
overlay=True).add_to(map)
# Plotting the area of search
folium.features.GeoJson(data=route_directions,
name='Route',
overlay=True).add_to(map)
# Create the html
updated_map_path = "C:/Users/daphn/Documents/EUvsVirus/visu/test.html"
map.save(updated_map_path)
return open(updated_map_path, 'r').read()
('UBSF-20/24 PETECAS/CRIOULI', [-4.267368 , -41.758368, ubsf20, ttp20, ppp20])]
locais3 = ['Unidades Fechadas']
if hora in range(7, 11) and dia in range(0,5):
locais = locais1
elif hora in range(13, 16) and dia in range(0,5):
locais = locais2
else:
locais = locais3
#estilo da rota
style = {'color': '#fd2b85'}
# API do openroute services
api_key = '5b3ce3597851110001cf6248ce9c379b4c0446d6abf7ea0d29cd0da0'
clnt = client.Client(key=api_key) # Create client with api key
w = widgets.Dropdown(
options= locais,
description='UBSF:',
)
def on_change(change):
if change['type'] == 'change' and change['name'] == 'value':
clear_output(wait=True)
display(w)
valor = w.value
print(valor)
lat1 = valor[0]
lon1 = valor[1]
ubs = valor[2]
mapa = folium.Map (location = [-4.275,-41.78],
color=color,
opacity=0.5,
weight=4,
)
# -
# ### Regular Route
#
# So far: The shortest route for a car from A to B.
# +
# Basic parameters
api_key = 'your_key' # https://openrouteservice.org/sign-up
ors = client.Client(key=api_key)
map_berlin = folium.Map(
tiles='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
attr=
'© <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>',
location=([52.516586, 13.381047]),
zoom_start=13.5) # Create map
popup_route = "<h4>{0} route</h4><hr>" \
"<strong>Duration: </strong>{1:.1f} mins<br>" \
"<strong>Distance: </strong>{2:.3f} km"
# Request route
coordinates = [[13.372582, 52.520295], [13.391476, 52.508856]]
direction_params = {
import os
from pathlib import Path
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import httpx
from openrouteservice import client
from openrouteservice.geocode import pelias_search as geocode
OPENROUTESERVICE_TOKEN = os.environ['OPENROUTESERVICE_TOKEN']
DGT_URL = 'http://infocar.dgt.es/etraffic/BuscarElementos?latNS=44&longNS=5&latSW=27&longSW=-19&zoom=6&accion=getElementos&Camaras=true&SensoresTrafico=true&SensoresMeteorologico=true&Paneles=true&Radares=true&IncidenciasRETENCION=true&IncidenciasOBRAS=false&IncidenciasMETEOROLOGICA=true&IncidenciasPUERTOS=true&IncidenciasOTROS=true&IncidenciasEVENTOS=true&IncidenciasRESTRICCIONES=true&niveles=true&caracter=acontecimiento'
openroute = client.Client(key=OPENROUTESERVICE_TOKEN)
app = FastAPI()
app.mount(
"/static",
StaticFiles(directory=Path(__file__).parent.parent.absolute() / "static"),
name="static",
)
templates = Jinja2Templates(directory="templates")
@app.get("/")
async def root(request: Request):
return templates.TemplateResponse("index.html", {"request": request})
@app.get("/events")
async def get_dgt_events():
def update_map(n_clicks, add_start, add_end, fearlevel):
if any([add_end is None, add_start is None]):
return my_input().initial_map()
else:
# 1. Reverse-geocoding (i.e finding geo coordinates from addresses)
# Also handles lat/long
if re.match(r"(\d{1,2}\.\d{1,12})", add_start) is None:
geocod_start = geocoder.osm(add_start)
start_lat = geocod_start.lat
start_lng = geocod_start.lng
else:
start_lat = float(add_start.split(" ")[0])
start_lng = float(add_start.split(" ")[1])
if re.match(r"(\d{1,2}\.\d{1,12})", add_end) is None:
geocod_end = geocoder.osm(add_end)
end_lat = geocod_end.lat
end_lng = geocod_end.lng
else:
end_lat = float(add_end.split(" ")[0])
end_lng = float(add_end.split(" ")[1])
# 2. Compute the box to look for POI around
box = [(start_lat, end_lng), (end_lat, end_lng), (end_lat, start_lng),
(start_lat, start_lng)]
poly_box = Polygon(box)
poly_box = poly_box.buffer(0.005).simplify(0.05)
# 3. Retrieve the POI in the area
try:
api = overpy.Overpass()
result_nodes = api.query(
"(node['shop']{0};node['amenity']{0};);out;".format(
str(poly_box.exterior.bounds)))
result_areas = api.query(
"(area['shop']{0};area['amenity']{0};);out;".format(
str(poly_box.exterior.bounds)))
except overpy.exception.OverpassGatewayTimeout:
return """<h1 style="color:white;">TOO MANY ELEMENTS ON THE WAY!</h1>"""
# 4. Filter the POI in the box to keep only the points to be avoid
# Loading the csv for the danger levels
dang_list = pd.read_csv(os.path.join(
APP_PATH, os.path.join("assets", "DangerScoreList.csv")),
delimiter=',')
# Score the POI in the area
nodes_score = add_score(
dang_list, result_nodes
) # nodes_score is a list of overpy objects, with lat and lon info,
dangers_poly = [] # sites_poly
# I define dangerous a POI with score greater than 1
for node in nodes_score:
try:
if node.tags['dangerscore'] >= fearlevel:
lat = node.lat
lon = node.lon
dangers_poly_coords = Point(
lon, lat).buffer(0.0005).simplify(0.05)
dangers_poly.append(dangers_poly_coords)
except:
pass
danger_buffer_poly = [
] # site_buffer_poly, which is the input for the avoid polygon option
for danger_poly in dangers_poly:
poly = Polygon(danger_poly)
danger_buffer_poly.append(poly)
# 5.Request the route
route_request = {
'coordinates': [[start_lng, start_lat], [end_lng, end_lat]],
# Careful long then lat and not lat then long
'format_out': 'geojson',
'profile': 'foot-walking',
'preference': 'shortest',
'instructions': False,
'options': {
'avoid_polygons': mapping(MultiPolygon(danger_buffer_poly))
}
}
api_key = '5b3ce3597851110001cf6248d14c60f017174b11b170ff63fdbf48b3'
clnt = client.Client(key=api_key)
try:
route_directions = clnt.directions(**route_request)
except openrouteservice.exceptions.ApiError:
return """<h1 style="color:white;">MISSION TOO DANGEROUS!</h1>"""
# 6.Display the route and the dangerous points
# Create the base map
map = folium.Map(tiles=my_input().map_background,
location=([start_lat, start_lng]),
zoom_start=14) # Create map
# Beginning and end markers
folium.Marker([start_lat, start_lng],
popup='<i>Start:</i> <b>{}</b>'.format(add_start),
icon=folium.Icon(color="green",
icon="street-view",
prefix="fa")).add_to(map)
folium.Marker([end_lat, end_lng],
popup='<i>End:</i> <b>{}</b>'.format(add_end),
icon=folium.Icon(icon="fa-check-square",
prefix="fa")).add_to(map)
# Plotting the route
style_route = {'fillColor': 'green', 'color': 'green', "weight": 5}
folium.features.GeoJson(data=route_directions,
name='Route',
style_function=lambda x: style_route,
overlay=True).add_to(map)
# Plotting the dangerous areas
# style_danger = {'fillColor': '#f88494', 'color': '#ff334f'}
# folium.features.GeoJson(data=mapping(MultiPolygon(danger_buffer_poly)),
# style_function=lambda x: style_danger,
# overlay=True).add_to(map)
# Adding icons (I haven't found dragons actually available :( )
for node in nodes_score:
if node.tags['dangerscore'] >= fearlevel:
# Retrieve the type of place
if "amenity" in node.tags:
type_place = node.tags["amenity"]
else:
type_place = node.tags["shop"]
# Create the markers
if node.tags['dangerscore'] == 3:
folium.Marker([node.lat, node.lon],
popup='<b>{}</b>'.format(type_place),
icon=folium.features.CustomIcon(
os.path.join(
APP_PATH,
os.path.join("assets", "skull.png")),
icon_size=(30, 30))).add_to(map)
elif node.tags['dangerscore'] == 2:
folium.Marker(
[node.lat, node.lon],
popup='<b>{}</b>'.format(type_place),
icon=folium.features.CustomIcon(
random.choice([
os.path.join(
APP_PATH,
os.path.join("assets",
"dragon1_purple.png")),
os.path.join(
APP_PATH,
os.path.join("assets", "spat.png")),
os.path.join(
APP_PATH,
os.path.join("assets", "dragon2.png"))
]),
icon_size=(30, 30))).add_to(map)
else:
folium.Marker([node.lat, node.lon],
popup='<b>{}</b>'.format(type_place),
icon=folium.features.CustomIcon(
os.path.join(
APP_PATH,
os.path.join("assets", "ghost.png")),
icon_size=(30, 30))).add_to(map)
# Create legend
# legend_html = """
# <div style ="position: fixed; bottom: 50px; left: 50px; width: 200px;
# height: 150px;z-index: 9999; font-size: 12px;"> <h5 style="font-family:verdana;">Legend</h5>
# <div class="figure"> <img src="{0}"; width="25"; height="25""> High risk</div><br>
# <div class="figure"> <img src="{1}"; width="25"; height="25"> Medium risk</div><br>
# <div class="figure"> <img src="{2}"; width="25"; height="25"> Low</div><br>
# </div>
# """.format(os.path.join(APP_PATH, os.path.join("assets", "skull.png")),
# os.path.join(APP_PATH, os.path.join("assets", "dragon1_purple.png")),
# os.path.join(APP_PATH, os.path.join("assets", "ghost.png")))
#
# map.get_root().html.add_child(folium.Element(legend_html))
# Add the lat long pop-up on click
map.add_child(folium.LatLngPopup())
return map._repr_html_()
def seiu(lat, lon, time):
print("")
# request reverse geocoding
r = requests.get(
'https://api.opencagedata.com/geocode/v1/json?q=%s+%s&key=7e95a1a406154911b68bfff0a5bf9c34'
% (lat, lon))
results = r.json()
where = results['results'][0]['formatted']
print("Your location is:", where)
# load csv
df_ca = pd.read_csv('supporting documents/Dialysis_CA.csv')
df_la = pd.read_csv('supporting documents/Dialysis_LA.csv')
df_seiu = pd.read_csv('supporting documents/SEIU_UHW_CA.csv')
# handle lat lon as floats
df_seiu['lat'] = df_seiu['lat'].astype(float)
df_seiu['lon'] = df_seiu['lon'].astype(float)
df_ca['lat'] = df_ca['lat'].astype(float)
df_ca['lon'] = df_ca['lon'].astype(float)
df_la['lat'] = df_la['lat'].astype(float)
df_la['lon'] = df_la['lon'].astype(float)
# map
map = folium.Map(location=[36.7783, -119.4179],
tiles='Stamen Toner',
zoom_start=5.5)
# plugin for MeasureControl
map.add_child(MeasureControl())
# float image plugin for logo
logo = ('https://i.imgur.com/WTmLCbc.png')
justice = ('https://i.imgur.com/mJgkwHV.png')
FloatImage(logo, bottom=8, left=4).add_to(map)
FloatImage(justice, bottom=.5, left=4).add_to(map)
fg = folium.FeatureGroup(name='Heat Map of Dialysis Clinics').add_to(map)
heat_df = df_ca[['lat', 'lon']]
heat_data = [[row['lat'], row['lon']] for index, row in heat_df.iterrows()]
HeatMap(heat_data, radius=15, blur=17).add_to(fg)
# clinics in CA
clinic_df = df_ca[['lat', 'lon']]
clinic_data = [[r['lat'], r['lon']] for i, r in clinic_df.iterrows()]
fg_1 = folium.FeatureGroup(name='Dialysis Clinics').add_to(map)
marker_cluster = MarkerCluster().add_to(fg_1)
for point in range(0, len(clinic_data)):
folium.Marker(clinic_data[point],
popup='<strong>' + "Facility: " +
df_ca['Facility N'][point] + " - Address:"
'</strong>' + df_ca['Address Li'][point],
icon=folium.Icon(color='beige',
icon_color='darkpurple',
icon='plus')).add_to(marker_cluster)
# SEIU offices
seiu_df = df_seiu[['lat', 'lon']]
seiu_data = [[r['lat'], r['lon']] for i, r in seiu_df.iterrows()]
fg_2 = folium.FeatureGroup(name='SEIU UHW Offices').add_to(map)
for point in range(0, len(seiu_data)):
folium.Marker(seiu_data[point],
popup='<strong>' + "SEIU Office: " +
df_seiu['SEIU UHW'][point] + " - Address:"
'</strong>' + df_seiu['Address'][point],
icon=folium.Icon(color='darkpurple',
icon_color='white',
icon='heart')).add_to(fg_2)
folium.LayerControl(collapsed=False).add_to(map)
map.save('MapFinal1.html')
# Service Area
loc = [[lon, lat]]
loc_df = pd.DataFrame(loc, columns=['lon', 'lat'])
org_df = loc_df[['lat', 'lon']]
org_data = [[r['lat'], r['lon']] for i, r in org_df.iterrows()]
map2 = folium.Map(location=[float(lat), float(lon)],
tiles='Stamen Toner',
zoom_start=11)
FloatImage(logo, bottom=8, left=4).add_to(map2)
FloatImage(justice, bottom=.5, left=4).add_to(map2)
for point in range(0, len(org_data)):
folium.Marker(org_data[point],
popup='<strong>'
"Your Input Location:" + where + '</strong>',
icon=folium.Icon(color='darkpurple',
icon_color='white',
icon='user')).add_to(map2)
key = '5b3ce3597851110001cf6248c13297498fc24a73a4067bd7d1a87f7d'
clnt = client.Client(key=key)
# parameters for isochrones request
params_iso = {
'profile': 'driving-car',
'range': [time * 60],
'interval': time * 60
}
loc_dict = {'loc': {'location': [lon, lat]}}
for name, loc in loc_dict.items():
params_iso['locations'] = [loc['location']]
iso = clnt.isochrones(**params_iso)
folium.features.GeoJson(iso).add_to(map2)
iso_buffer = Polygon(iso['features'][0]['geometry']['coordinates'][0])
folium.features.GeoJson(data=mapping(iso_buffer),
name='Drive Time Isochrone',
overlay=True).add_to(map2)
# reverse lat lon df
clinic_r_a = df_ca[['lat', 'lon', 'Address Li', 'Facility N']]
clinic_r_a_data = [[r['lon'], r['lat'], r['Address Li'], r['Facility N']]
for i, r in clinic_r_a.iterrows()]
print("")
print("Clinics within" + " " + str(time) + " " + "minute(s) of driving" +
": ")
print("")
for clinic in clinic_r_a_data:
point = Point(clinic)
if iso_buffer.contains(point):
omglol = clinic[3] + " at " + clinic[2]
folium.Marker(list(reversed(point.coords[0])),
popup='<strong>' + "Clinics within" + " " +
str(time) + " " + "minute(s) of driving" +
'</strong>' + ": " + omglol,
icon=folium.Icon(color='beige',
icon_color='darkpurple',
icon='plus')).add_to(map2)
params_route = {
'profile': 'driving-car',
'format_out': 'geojson',
'geometry': 'true',
'format': 'geojson',
'instructions': 'true',
'preference': 'recommended'
}
def style_function(color):
return lambda feature: dict(color=color, weight=3, opacity=1)
for clinic in clinic_r_a_data:
point = Point(clinic)
for name, loc in loc_dict.items():
org_coord = loc['location']
if iso_buffer.contains(point):
omglol = clinic[3] + " at " + clinic[2]
clinic_coord = [clinic[0], clinic[1]]
params_route['coordinates'] = [org_coord, clinic_coord]
json_route = clnt.directions(**params_route)
folium.features.GeoJson(
json_route,
style_function=style_function("#ffff00")).add_to(map2)
folium.Marker(list(reversed(point.coords[0])),
popup='<strong>' + "Clinics within" + " " +
str(time) + " " + "minute(s) of driving" +
'</strong>' + ": " + omglol,
icon=folium.Icon(color='beige',
icon_color='darkpurple',
icon='plus')).add_to(map2)
print(omglol)
print("Driving distance in minute(s):")
print(
(json_route['features'][0]['properties']['summary']['duration']
) / 60)
print("")
map2.save('MapFinal2.html')
