tube_gp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:00:22.460264Z",
     "start_time": "2022-03-15T17:00:05.086944Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import libraries using Python 3.8\n",
    "\n",
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "import seaborn as sns\n",
    "import networkx as nx\n",
    "import urllib.request\n",
    "import zipfile\n",
    "import networkx as nx\n",
    "import osmnx as ox\n",
    "import geopandas as gpd\n",
    "import folium\n",
    "import requests\n",
    "from descartes import PolygonPatch\n",
    "from shapely.geometry import Point, LineString, Polygon\n",
    "from shapely.ops import cascaded_union\n",
    "from geopy.geocoders import Nominatim\n",
    "from geopy.extra.rate_limiter import RateLimiter\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:00:24.456677Z",
     "start_time": "2022-03-15T17:00:24.435740Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Reading in the London Transport dataset, edges and nodes. \n",
    "\n",
    "df_raw = pd.read_csv(\n",
    "    '../data/london_transport_raw.edges', sep=' ', header=None)\n",
    "\n",
    "df_raw.columns = ['line', 'station_1', 'station_2']\n",
    "print(df_raw.shape)\n",
    "df_raw.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_raw.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataset of London Underground interstation train times found on this website, \n",
    "# 'https://www.whatdotheyknow.com/request/station_to_station_journey_times'\n",
    "\n",
    "\n",
    "df_time = pd.read_csv(\n",
    "    '../data/InterStationTrainTimes.csv', sep=',', header=None)\n",
    "df_time = df_time.iloc[3: , :8]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some EDA on the dataset to join with the LT dataset.\n",
    "\n",
    "df_time.columns = ['line', 'direction', 'station_1', 'station_2', 'distance','un-impeded','am_peak','duration']\n",
    "df_time = df_time.apply(lambda x: x.str.replace(' ',''))\n",
    "df_time = df_time.apply(lambda x: x.str.lower())\n",
    "df_time.head(2)\n",
    "df_time.shape\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reducing the columns to the ones needed to merge to df_raw\n",
    "\n",
    "df_time1 = df_time[['line','station_1','station_2','duration']]\n",
    "df_time1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# merging df_raw with the LU train times \n",
    "\n",
    "df_new3 = df_raw.merge(df_time1, how = 'inner', on=['line','station_1','station_2'])\n",
    "df_new3.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:00:34.330271Z",
     "start_time": "2022-03-15T17:00:34.303900Z"
    }
   },
   "outputs": [],
   "source": [
    "# df_raw line check\n",
    "\n",
    "df_raw.line.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:00:35.437994Z",
     "start_time": "2022-03-15T17:00:35.415676Z"
    }
   },
   "outputs": [],
   "source": [
    "# reading in the London Transport nodes dataset\n",
    "\n",
    "df_nodes = pd.read_csv(\n",
    "    '../data/london_transport_nodes.txt', sep=' ')\n",
    "print(df_nodes.shape)\n",
    "df_nodes.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:00:41.686589Z",
     "start_time": "2022-03-15T17:00:41.640815Z"
    }
   },
   "outputs": [],
   "source": [
    "# reading in the London Transport multiplex dataset\n",
    "\n",
    "df_multiplex = pd.read_csv(\n",
    "    '../data/london_transport_multiplex.edges', sep=' ', header=None)\n",
    "df_multiplex.columns = ['layer', 'node_1', 'node_2', 'weight']\n",
    "print(df_multiplex.shape)\n",
    "df_multiplex.head()\n",
    "len(set(df_multiplex[df_multiplex.layer == 1]\n",
    "        [['node_1', 'node_2']].values.flatten()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:03.893723Z",
     "start_time": "2022-03-15T17:01:03.857536Z"
    }
   },
   "outputs": [],
   "source": [
    "# reading in the London Transport layers dataset. This defines tube vs overground vs DLR\n",
    "\n",
    "df_layers = pd.read_csv(\n",
    "    '../data/london_transport_layers.txt', sep='\\t')\n",
    "df_layers['layerID'] = [int(x[0]) for x in list(df_layers.iloc[:, 0])]\n",
    "df_layers['layerLabel'] = [x[2:] for x in list(df_layers.iloc[:, 0])]\n",
    "df_layers.drop(df_layers.columns[0], axis=1, inplace=True)\n",
    "df_layers.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:06.865928Z",
     "start_time": "2022-03-15T17:01:06.828896Z"
    }
   },
   "outputs": [],
   "source": [
    "df_multiplex[df_multiplex.layer == 1].loc[:, 'node_1':].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:11.000013Z",
     "start_time": "2022-03-15T17:01:10.967525Z"
    }
   },
   "outputs": [],
   "source": [
    "# adding the dataset nodes and edges together\n",
    "\n",
    "data_1 = df_multiplex[df_multiplex.layer == 1].loc[:, 'node_1':].values\n",
    "data_2 = df_multiplex[df_multiplex.layer == 2].loc[:, 'node_1':].values\n",
    "data_3 = df_multiplex[df_multiplex.layer == 3].loc[:, 'node_1':].values\n",
    "G_tube = nx.Graph()\n",
    "G_tube.add_nodes_from(list(range(0, 369)))\n",
    "G_tube.add_weighted_edges_from(data_1)\n",
    "\n",
    "G_overground = nx.Graph()\n",
    "G_overground.add_nodes_from(list(range(0, 369)))\n",
    "G_overground.add_weighted_edges_from(data_2)\n",
    "\n",
    "G_DLR = nx.Graph()\n",
    "G_DLR.add_nodes_from(list(range(0, 369)))\n",
    "G_DLR.add_weighted_edges_from(data_3)\n",
    "\n",
    "G_TO = nx.Graph()\n",
    "G_TO.add_nodes_from(list(range(0, 369)))\n",
    "G_TO.add_weighted_edges_from(data_1)\n",
    "G_TO.add_weighted_edges_from(data_2)\n",
    "\n",
    "G_TD = nx.Graph()\n",
    "G_TD.add_nodes_from(list(range(0, 369)))\n",
    "G_TD.add_weighted_edges_from(data_1)\n",
    "G_TD.add_weighted_edges_from(data_3)\n",
    "\n",
    "G_OD = nx.Graph()\n",
    "G_OD.add_nodes_from(list(range(0, 369)))\n",
    "G_OD.add_weighted_edges_from(data_2)\n",
    "G_OD.add_weighted_edges_from(data_3)\n",
    "\n",
    "G_all = nx.Graph()\n",
    "G_all.add_nodes_from(list(range(0, 369)))\n",
    "G_all.add_weighted_edges_from(data_1)\n",
    "G_all.add_weighted_edges_from(data_2)\n",
    "G_all.add_weighted_edges_from(data_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:13.171511Z",
     "start_time": "2022-03-15T17:01:13.156547Z"
    }
   },
   "outputs": [],
   "source": [
    "# dictionary zipping the different layers to each other\n",
    "\n",
    "graph_dict = dict(list(zip(['G_tube', 'G_overground', 'G_DLR', 'G_TO', 'G_TD', 'G_OD', 'G_all'],\n",
    "                           [G_tube, G_overground, G_DLR, G_TO, G_TD, G_OD, G_all])))\n",
    "for key in graph_dict:\n",
    "    print(key)\n",
    "    print(nx.info(graph_dict[key]))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:25.090716Z",
     "start_time": "2022-03-15T17:01:25.070365Z"
    }
   },
   "outputs": [],
   "source": [
    "# defining the three layers, edge values being added for each of tube, overground and DLR\n",
    "\n",
    "color_labels_tube = [list(edge[2].values())[0] for edge in G_tube.edges(data=True)]\n",
    "color_labels_DLR = [list(edge[2].values())[0] for edge in G_DLR.edges(data=True)]\n",
    "color_labels_overground = [list(edge[2].values())[0] for edge in G_overground.edges(data=True)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:43.782352Z",
     "start_time": "2022-03-15T17:01:43.116385Z"
    }
   },
   "outputs": [],
   "source": [
    "# Graph in networkx to show the London Transport map, and 3 layers of transport as different colours\n",
    "\n",
    "pos_dict = {}\n",
    "for key in df_nodes.nodeID:\n",
    "    # list(df_nodes.iloc[key,2:])\n",
    "    pos_dict[key] = list(df_nodes.loc[key, ['nodeLong', 'nodeLat']].values)\n",
    "\n",
    "plt.figure(figsize=(10, 10))\n",
    "nx.draw(G_tube, pos=pos_dict, node_size=20, edge_color='red')\n",
    "nx.draw(G_overground, pos=pos_dict, node_size=20, edge_color='blue')\n",
    "nx.draw(G_DLR, pos=pos_dict, node_size=20, edge_color='green')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was as far as I got with the London Transport dataset in the time we had to code. The aim had been to present the transit network as above, add in train times, and then layer this into the OSMnx code below, with the final output being a search from station to GP practice, with transit route and time from one point to another. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using OSMnx this next section imported the GP practices dataset and modelled distance times from this using isochrones\n",
    "\n",
    "# GP Practice Data Processing\n",
    "#-----------------------------------------\n",
    "gp_practice_df_2 = pd.read_csv('../data/gp_pop_london_mapped_final.csv')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Folium map visualisation of London GP practices\n",
    "#-----------------------------------------\n",
    "frame = folium.Figure(width=500, height=500)\n",
    "folium_fig = folium.Map(\n",
    "    location=[51.50, -0.123],\n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=10).add_to(frame)\n",
    "for code, name, address, number, lat, lon in zip(gp_practice_df_2['Organisation Code'],\n",
    "gp_practice_df_2['Name'],\n",
    "gp_practice_df_2['Address'],\n",
    "gp_practice_df_2['Contact Telephone Number'],\n",
    "gp_practice_df_2['Latitude'],\n",
    "gp_practice_df_2['Longitude']):\n",
    "    folium.Marker(\n",
    "        [lat, lon],\n",
    "        popup = folium.Popup('<b>' + 'Name: ' + '</b>'  + str(name) + '<br>'\n",
    "        '<b>' + 'GP Practice Code: ' + '</b>' + str(code) + '<br>'\n",
    "        '<b>' + 'Address: ' + '</b>' + str(address) + '<br>'\n",
    "        '<b>' + 'Telephone Number: ' + '</b>' + str(number) + '<br>',\n",
    "        max_width=len(address)*20),\n",
    "        icon=folium.Icon(color=\"darkblue\", prefix='fa', icon=\"fa-medkit\"),\n",
    "        ).add_to(folium_fig)\n",
    "folium_fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import London network and change node labels to integers, transport mode here is drive\n",
    "\n",
    "place = \"London, England\"\n",
    "\n",
    "mode = \"drive\"\n",
    "\n",
    "Gp = ox.graph_from_place(place, network_type=\"drive\")\n",
    "#Gp = ox.project_graph(G)\n",
    "ox.plot_graph(Gp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As this is a London driving map, the map looks a little crowded and hard to see the data\n",
    "\n",
    "ox.plot_graph(Gp);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# If a node cannot access at least 10% of other nodes, delete it (isolated)\n",
    "#num_nodes = len(G.nodes)\n",
    "#remove_list = []\n",
    "#for node in G.nodes:  \n",
    "#    reach = len(nx.descendants(G, node))\n",
    "#    if reach < num_nodes / 10:\n",
    "#        remove_list.append(node)\n",
    "\n",
    "#for node in remove_list:\n",
    "#    G.remove_node(node)\n",
    "\n",
    "#G = nx.convert_node_labels_to_integers(G, label_attribute='old_node_ID')\n",
    "#ox.plot_graph(G);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to run any location, distance, transport mode, in OSMnx via the address or lat/ long points. \n",
    "\n",
    "def create_graph(loc, dist, transport_mode, loc_type = \"address\"):\n",
    "\n",
    "    if loc_type == \"address\":\n",
    "        G = ox.graph_from_address(loc, distance = dist, network_type = transport_mode)\n",
    "    elif loc_type == \"points\":\n",
    "        G = ox.graph_from_point(loc, distance = dist, network_type = transport_mode)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This box shows the custom filter functionality in OSMnx, where other transport modes can be selected/ tried\n",
    "# Default transport modes are 'walk', 'drive', 'private-hire'\n",
    "# Running the OSMnx map for London, with a custom filter, selecting 'railway' or 'rail/tram' \n",
    "\n",
    "Gp1 = ox.graph_from_place(\"London, England\", custom_filter='[\"railway\"~\"rail|tram\"]',\n",
    " \n",
    "                        retain_all=False, truncate_by_edge=True, simplify=True)\n",
    "len(Gp1) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the output from the box above, tight layout fits the area into a small frame for easier viewing\n",
    "\n",
    "Gp1\n",
    "fig, ax = ox.plot_graph(Gp1);\n",
    "plt.tight_layout()\n",
    "plt.show();\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding nodes to the df\n",
    "\n",
    "point_of_interest = ox.distance.nearest_nodes(Gp1, X = df_nodes['nodeLong'], Y=df_nodes['nodeLat'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here adding in the isochrone trip times and travel speed for the maps\n",
    "\n",
    "# Trip time in Mintues\n",
    "trip_times = [10,20,30]\n",
    "\n",
    "# tube speed in km/hour\n",
    "travel_speed = 45.0\n",
    "\n",
    "# add an edge attribute for time in minutes required to traverse each edge\n",
    "meters_per_minute = travel_speed * 1000 / 60 #km per hour to m per minute\n",
    "for u, v, k, data in Gp1.edges(data=True, keys=True):\n",
    "    data['time'] = data['length'] / meters_per_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the London rail transit map using OSMnx\n",
    "\n",
    "# 1 - get one color for each isochrone\n",
    "iso_colors = ox.plot.get_colors(n=len(trip_times), cmap='Reds', start=0.3, return_hex=True)\n",
    "# 2 - color the nodes according to isochrone then plot the street network\n",
    "node_colors = {}\n",
    "for trip_time, color in zip(sorted(trip_times, reverse=True), iso_colors):\n",
    "    for points in point_of_interest:\n",
    "        subgraph = nx.ego_graph(Gp1, points, radius=trip_time, distance='time')\n",
    "        for node in subgraph.nodes():\n",
    "            node_colors[node] = color\n",
    "nc = [node_colors[node] if node in node_colors else 'none' for node in Gp1.nodes()]\n",
    "ns = [10 if node in node_colors else 0 for node in Gp1.nodes()]\n",
    "fig, ax = ox.plot_graph(Gp1, node_color=nc, node_size=ns, node_alpha=0.8, node_zorder=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make the isochrone polygons\n",
    "\n",
    "isochrone_polys = []\n",
    "for trip_time in sorted(trip_times, reverse=True):\n",
    "    isochrone_polys_sub = []\n",
    "    for points in point_of_interest:\n",
    "        subgraph = nx.ego_graph(Gp1, points, radius=trip_time, distance='time')\n",
    "        node_points = [Point((data['x'], data['y'])) for node, data in subgraph.nodes(data=True)]\n",
    "        bounding_poly = gpd.GeoSeries(node_points).unary_union.convex_hull\n",
    "        isochrone_polys_sub.append(bounding_poly)\n",
    "    isochrone_polys.append(isochrone_polys_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_map = ox.plot_graph_folium(Gp1, folium_fig, color=\"#425563\", opacity=0.5, weight=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Folium map overlayed with the isochrones\n",
    "\n",
    "style_geojson = [\n",
    "{'shape_name': '20 min walk','shape_fillColor': '#003087'},\n",
    "{'shape_name': '10 min walk', 'shape_fillColor': '#005EB8'},\n",
    "{'shape_name': '5 min walk', 'shape_fillColor': '#41B6E6'}]\n",
    "gdf_index = list(gp_practice_df_2.index)\n",
    "for polygon, style in zip(isochrone_polys, style_geojson):\n",
    "     gdf = gpd.GeoDataFrame({\"GP Practice\": gdf_index}, geometry= polygon)\n",
    "     polygon_json = list(gdf['geometry'])\n",
    "     geojson = gpd.GeoSeries(cascaded_union(polygon_json)).to_json()\n",
    "     fillColor = style['shape_fillColor']\n",
    "     shape_name = style['shape_name']\n",
    "     folium.GeoJson(geojson, name = shape_name, style_function = lambda x, fillColor = fillColor: {\n",
    "            \"fillColor\": fillColor,\n",
    "            \"name\":  shape_name,\n",
    "            \"weight\": 1,\n",
    "            \"fillOpacity\": 0.5,\n",
    "            \"color\": \"#000000\"\n",
    "            }).add_to(folium_fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:01:56.440798Z",
     "start_time": "2022-03-15T17:01:54.831291Z"
    }
   },
   "outputs": [],
   "source": [
    "# Working out diameters/ distances in the London Transport transit map, connecting the three layers\n",
    "\n",
    "G_tube_connected = [G_tube.subgraph(G) for G in nx.connected_components(\n",
    "    G_tube) if G_tube.subgraph(G).number_of_nodes() > 1][0]\n",
    "G_overground_connected = [G_overground.subgraph(G) for G in nx.connected_components(\n",
    "    G_overground) if G_overground.subgraph(G).number_of_nodes() > 1][0]\n",
    "G_DLR_connected = [G_DLR.subgraph(G) for G in nx.connected_components(\n",
    "    G_DLR) if G_DLR.subgraph(G).number_of_nodes() > 1][0]\n",
    "G_all_connected = [G_all.subgraph(G) for G in nx.connected_components(\n",
    "    G_all) if G_all.subgraph(G).number_of_nodes() > 1][0]\n",
    "\n",
    "connected_graphs = [G_tube_connected,\n",
    "                    G_overground_connected, G_DLR_connected, G_all_connected]\n",
    "\n",
    "for G in connected_graphs:\n",
    "    print(nx.diameter(G))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:02:02.218060Z",
     "start_time": "2022-03-15T17:02:02.191374Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function to define shortest path in the London Transport node network graph\n",
    "\n",
    "def your_shortest_path(G, start_station, end_station, df_nodes=df_nodes, df_raw=df_raw):\n",
    "    nodecheck = 1\n",
    "    try:\n",
    "        start_node = int(df_nodes.nodeID[df_nodes.nodeLabel == start_station])\n",
    "    except:\n",
    "        print('Your start point does not exist.')\n",
    "        nodecheck = 0\n",
    "    try:\n",
    "        end_node = int(df_nodes.nodeID[df_nodes.nodeLabel == end_station])\n",
    "    except:\n",
    "        print('Your start point does not exist.')\n",
    "        nodecheck = 0\n",
    "    if nodecheck == 1:\n",
    "        try:\n",
    "            pathlength = nx.shortest_path_length(G, start_node, end_node)\n",
    "            path = nx.shortest_path(G, start_node, end_node)\n",
    "            print(\"The shortest path from {} to {} crosses\".format(\n",
    "                start_station, end_station), end=' ')\n",
    "            print((', ').join(list(df_nodes.nodeLabel[path])[1:-1])+\".\")\n",
    "            print(\"The path length is\", str(pathlength)+'.')\n",
    "            print(\"You will have to take the following lines:\")\n",
    "            connection = list(\n",
    "                df_nodes.nodeLabel[nx.shortest_path(G, start_node, end_node)])\n",
    "            lines = []\n",
    "            for i in range(len(connection)-1):\n",
    "                conn = list(df_raw.line[((df_raw.station_1 == connection[i]) & (df_raw.station_2 == connection[i+1])) |\n",
    "                                        ((df_raw.station_1 == connection[i+1]) & (df_raw.station_2 == connection[i]))])\n",
    "                if len(conn) > 1:\n",
    "                    conn = (' or ').join(conn)\n",
    "                else:\n",
    "                    conn = conn[0]\n",
    "                if conn not in lines:\n",
    "                    lines.append(conn)\n",
    "            print((', ').join(lines))\n",
    "        except:\n",
    "            print(\"There is no path between {} and {}.\".format(\n",
    "                start_station, end_station))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:02:07.403016Z",
     "start_time": "2022-03-15T17:02:07.371698Z"
    }
   },
   "outputs": [],
   "source": [
    "# Sample of this function working. Here to use this, input any two stations in the network\n",
    "\n",
    "your_shortest_path(G_all, 'stjohnswood', 'cockfosters')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-03-15T17:02:12.225923Z",
     "start_time": "2022-03-15T17:02:12.207819Z"
    }
   },
   "outputs": [],
   "source": [
    "# Second example \n",
    "\n",
    "your_shortest_path(G_all, 'warrenstreet', 'victoria')"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}