Assignment 4 – Transportation

# import libraries
import pandas as pd
import geopandas as gpd
import osmnx as ox
import networkx as nx
import matplotlib.pyplot as plt
import plotly as py
from shapely.geometry import Point, Polygon
import plotly.express as px
import requests
import folium
from pykml import parser

# get the graph of waterway in this part of city
graph_water = ox.graph_from_point(ox.geocoder.geocode("Henri Polaklaan, Amsterdam"), custom_filter='["waterway"~"canal|river"]', dist=1000, simplify=True)
fig, ax = ox.plot_graph(graph_water)

# get nodes in the waterway network
graph_water.nodes()
nodes = ox.graph_to_gdfs(graph_water, edges=False)
nodes[['x', 'y']]

# import the route we planned in Google Earth, which is a .kml file
with open('route.kml', 'rt') as f:
    doc = parser.parse(f)
root = doc.getroot()

# get the coordinates of points in the route
for placemark in root.Document.Placemark:
    coordinates = placemark.LineString.coordinates
    print(coordinates)

i = str(coordinates).strip()
p = i.split(' ')
route_points = []
for n in p:
    coor = n.split(',')
    route_points.append((float(coor[0]),float(coor[1])))
print(route_points)

# find related nodes in the network
swim_route = []
for i in range(0,len(route_points)):
    origin_point = (route_points[i][0],route_points[i][1])
    origin_node = ox.nearest_nodes(graph_water, route_points[i][0], route_points[i][1])
    swim_route.append(origin_node)

# delate repeat points
swim_route_update = []
previous_node = None
for node in swim_route:
    if node != previous_node:
        swim_route_update.append(node)
    previous_node = node
print(swim_route_update)

# get the swim route in the network
swim_route_path = []
for i in range(len(swim_route_update) - 1):
    path = nx.shortest_path(graph_water, swim_route_update[i], swim_route_update[i+1])
    swim_route_path.extend(path[1:])
print(swim_route_path)

# visualization
swim_route_fig, ax = ox.plot_graph_route(graph_water, swim_route_path, route_linewidth=2, route_color='red', show=True, orig_dest_size=2, bgcolor='white', node_color="lightgrey", edge_color="lightgrey",  close=False)

#calculate the center point of the route

x_co = 0.0
y_co = 0.0

for node in swim_route_path:
    x_co += graph_water.nodes[node]['x']
    y_co += graph_water.nodes[node]['y']

ave_x = x_co / len(swim_route_path)
ave_y = y_co / len(swim_route_path)
center_point = (ave_x, ave_y) 
center_point

#visualization
swim_route_fig, ax = ox.plot_graph_route(graph_water, swim_route_path, route_linewidth=2, route_color='red', show=False, orig_dest_size=2, bgcolor='white', node_color="lightgrey", edge_color="lightgrey",  close=False)
ax.scatter(ave_x, ave_y, c='red',marker = "+", s=200) 
plt.show()

# get the start and end nodes
start_point = graph_water.nodes[swim_route_path[0]]
end_point = graph_water.nodes[swim_route_path[-1]]

#find near stops
bus_stop = ox.features.features_from_point((start_point['y'], start_point['x']), tags={'public_transport':[ 'stop_position']}, dist=500)
bus_stop.to_csv("bus_stop.csv") 
print(bus_stop) 

#visualization
bus_stop_point = bus_stop.iloc[2, bus_stop.columns.get_loc('geometry')]
geo_df_bus_list = [[bus_stop_point.xy[1][0], bus_stop_point.xy[0][0]] for bus_stop_point in bus_stop.geometry]

AMS = folium.Map(location=(52.3737966,4.9148386), zoom_start=14, control_scale=True,tiles="CartoDB positron")

i = 0
for row_index, row in bus_stop.iterrows():
    mark =  folium.Marker(
                location=geo_df_bus_list[i],
                icon=folium.Icon(icon="car")
            )
    i += 1
    AMS.add_child(mark)

AMS

#get the network of Amsterdam
graph_city = ox.graph_from_place('Amsterdam', network_type = "all")
#graph_city = ox.graph_from_place('Amsterdam', network_type = "all", dist=1000)

#get the nearest nodes in the new network
start_node = ox.nearest_nodes(graph_city, start_point['x'], start_point['y'], return_dist= True)
end_node = ox.nearest_nodes(graph_city, end_point['x'], end_point['y'], return_dist= True)
center_node = ox.nearest_nodes(graph_city, center_point[0], center_point[1], return_dist= True)

#visualization
fig, ax = ox.plot_graph(graph_city, show = False, bgcolor='white', node_color="lightgrey", edge_color="lightgrey")
ax.scatter(4.9131553, 52.3710485, c='red',marker = "+", s=200) 
ax.scatter(4.9135805, 52.3709291, c='red',marker = "+", s=200) 
ax.scatter(4.9085689, 52.3663277, c='red',marker = "+", s=200) 
plt.show()

#calculate the centrality of each nodes
start_centrality = nx.closeness_centrality(graph_city, start_node[0])
center_centrality = nx.closeness_centrality(graph_city, center_node[0])
end_centrality = nx.closeness_centrality(graph_city, end_node[0])

#print

#get the network of Amsterdam
graph_city = ox.graph_from_place('Amsterdam', network_type = "all", dist=1000)

restaurant = ox.features_from_point((start_point['y'], start_point['x']), tags={'amenity':['restaurant','pub', 'bar','cafe','fast_food']}, dist=500)
restaurant = restaurant.loc['node']
restaurant.to_csv("restaurant.csv") 

#visualization
restaurant_point = restaurant.iloc[2, restaurant.columns.get_loc('geometry')]
geo_df_restaurant_list = [[restaurant_point.xy[1][0], restaurant_point.xy[0][0]] for restaurant_point in restaurant.geometry]

i = 0
for row_index, row in restaurant.iterrows():
    mark =  folium.Marker(
                location=geo_df_restaurant_list[i],
                icon=folium.Icon(color="green"),
                popup=(
                "Name: "
                + str(restaurant.name[row_index])
                )
            )
    i += 1
    AMS.add_child(mark)
AMS