walking_gp_practice_cambridge.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Python libraries (use Python >= v. 3.9.0)\n",
    "#-------------------------------------------------\n",
    "\n",
    "import networkx as nx\n",
    "import osmnx as ox\n",
    "import geopandas as gpd\n",
    "import matplotlib.pyplot as plt\n",
    "import urllib.request\n",
    "import pandas as pd\n",
    "import zipfile\n",
    "import folium\n",
    "import geojson\n",
    "\n",
    "from geopy.geocoders import Nominatim\n",
    "from geopy.extra.rate_limiter import RateLimiter\n",
    "from descartes import PolygonPatch\n",
    "from shapely.geometry import Point\n",
    "from shapely.ops import cascaded_union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download a geoJSON shapefile for the CB postcode areas (Cambirdge, UK) from GitHub\n",
    "#-----------------------------------------------------------------------------------\n",
    "try:\n",
    "    cb_geo_json_link =  'https://raw.githubusercontent.com/missinglink/uk-postcode-polygons/master/geojson/CB.geojson\"\n",
    "    cam_postcode_shapefile_r = urllib.request.urlopen(cb_geo_json_link)\n",
    "    cam_postcode_shapefile = geojson.loads(cam_postcode_shapefile_r.read())\n",
    "except:\n",
    "    with open('data/cambridge.geosjon') as f:\n",
    "        cam_postcode_shapefile = geojson.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the a pandas dataframe which define 5 'central Cambridge' postcodes (to allow for these areas to be visualised in a differnt colour in the choropleth layer)\n",
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "central_list = []\n",
    "postcodes = [\"CB1\", \"CB2\", \"CB3\", \"CB4\", \"CB5\"] #---------- the five postcodes defined as being 'central Cambridge'\n",
    "for numbers in range(0,16):\n",
    "    if cam_postcode_shapefile['features'][numbers]['properties']['name'] in postcodes:\n",
    "        data_cam = [cam_postcode_shapefile['features'][numbers]['properties']['name'],1] #---------- Central Postcodes asigned a value of 1 \n",
    "        central_list.append(data_cam)\n",
    "    else:\n",
    "        data_cam = [cam_postcode_shapefile['features'][numbers]['properties']['name'],0] #---------- Other Postcodes asigned a value of 0\n",
    "        central_list.append(data_cam)\n",
    "post_code_df = pd.DataFrame(central_list, columns = ['Postcode', 'Central Cambridge']) \n",
    "post_code_df['Postcode'] = post_code_df['Postcode'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a folium map visualising the areas covered by the Cambridge Postcodes\n",
    "#----------------------------------------------------------------------------\n",
    "\n",
    "#Defines the highlight and popup style for the choropleth layer\n",
    "#--------------------------------------------------------------\n",
    "style_function = lambda x: {'fillColor': '#ffffff', \n",
    "                            'color':'#000000', \n",
    "                           'fillOpacity': 0.1, \n",
    "                            'weight': 0.1}\n",
    "highlight_function = lambda x: {'fillColor': '#000000', \n",
    "                                'color':'#000000', \n",
    "                                'fillOpacity': 0.5, \n",
    "                                 'weight': 0.1}\n",
    "\n",
    "#Create the frame and background folium map \n",
    "#------------------------------------------\n",
    "frame = folium.Figure(width=500, height=500) #------ Map centred on Cambridge using coordinates\n",
    "cambridge_map = folium.Map(\n",
    "    location=[52.21, 0.15], \n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=9).add_to(frame)\n",
    "\n",
    "#Add a choropleth with the Cambridge postcode areas (with central postcodes differently coloured using the post_code_df)\n",
    "#------------------------------------------------------------------------------------------------------------------------\n",
    "chloro = folium.Choropleth(\n",
    "    geo_data= cam_postcode_shapefile,\n",
    "    data=post_code_df,\n",
    "    name = 'Cambridge Postcodes',\n",
    "    columns= ['Postcode', 'Central Cambridge'],\n",
    "    key_on='feature.properties.name',\n",
    "    fill_color=\"RdBu\",\n",
    "    fill_opacity=0.7,\n",
    "    line_opacity=1,\n",
    "    highlight = True,\n",
    "   )\n",
    "\n",
    "#Adding a toolip which appears on hover to the postcode choropleth layer\n",
    "#----------------------------------------------------------------------\n",
    "data_on_hover = folium.features.GeoJson(data = cam_postcode_shapefile, style_function=style_function, control=False, highlight_function=highlight_function, tooltip=folium.features.GeoJsonTooltip(\n",
    "    fields= ['name'], \n",
    "    aliases=['Postcode: '],\n",
    "    localize = True))\n",
    "\n",
    "#Removes the automatically generated folium legend from the map\n",
    "#--------------------------------------------------------------\n",
    "for key in chloro._children:\n",
    "    if key.startswith('color_map'):\n",
    "        del(chloro._children[key])\n",
    "#--------------------------------------------------------------\n",
    "\n",
    "cambridge_map.add_child(data_on_hover)\n",
    "cambridge_map.keep_in_front(data_on_hover)\n",
    "chloro.add_to(cambridge_map)\n",
    "folium.LayerControl().add_to(cambridge_map)\n",
    "\n",
    "#Saves the folium map as an html object for use in the webpage\n",
    "#--------------------------------------------------------------\n",
    "cambridge_map.save('images/folium/cambridge_postcode_map.html', \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EPRACCUR GP Practice data ingestion\n",
    "#-----------------------------------------\n",
    "\n",
    "#Retrvies and saves the most recent EPRACCUR dataset from NHS Digital  webpage\n",
    "#-----------------------------------------------------------------------------\n",
    "url = 'https://files.digital.nhs.uk/assets/ods/current/epraccur.zip'\n",
    "filehandle, _ = urllib.request.urlretrieve(url)\n",
    "zip_file_object = zipfile.ZipFile(filehandle, 'r')\n",
    "first_file = zip_file_object.namelist()[0]\n",
    "file = zip_file_object.open(first_file)\n",
    "content = file.read()\n",
    "csv_file = open('data/epraccur_data.csv', 'wb') #-------------- saves the data to the GitHub Repo\n",
    "csv_file.write(content)\n",
    "csv_file.close()\n",
    "header_list = [\"Organisation Code\", \"Name\", \"National Grouping\", \"High Level Health Geography\", \"Address line 1\", \"Address line 2\", \"Address line 3\", \n",
    "\"Address line 4\", \"Address line 5\",\"Postcode\",\"Open Date\",\"Close Date\",\"Status Code\",\"Organisation Sub-Type Code\",\"Commissioner\",\"Join Provider/Purchaser Date\",\n",
    "\"Left Provider/Purchaser Date\",\"Contact Telephone Number\", \"Null 1\", \"Null 2\", \"Null 3\", \"Amended Record Indicator\", \"Null 4\", \"Provider/Purchaser\",\n",
    "\"Null 5\", \"Prescribing Setting\", \"Null 6\"] #--------------- Column names are not in the raw data, passed to pandas using the header_list\n",
    " \n",
    "# GP Practice Data Processing\n",
    "#-----------------------------------------\n",
    "gp_practice_df = pd.read_csv('data/epraccur_data.csv', names=header_list)\n",
    "gp_practice_df = gp_practice_df[(gp_practice_df[\"Status Code\"] == \"A\") & (gp_practice_df[\"Prescribing Setting\"] == 4) #----------- Selecting only Active and Standard GP Practices form the data\n",
    "& (gp_practice_df[\"Postcode\"].str.contains('CB1 |CB2 |CB3 |CB4 |CB5 '))].reset_index(drop = True) #----------- Central cambridge defined as having the following postcodes: CB1, CB2, CB3, CB4, CB5\n",
    "gp_practice_df['Full Address'] = gp_practice_df[['Address line 2', 'Address line 3', 'Address line 4',]].astype(str).agg(', '.join, axis=1) #------- Joining the address data from various columns to get a full address\n",
    "gp_practice_df['Full Address'] = gp_practice_df['Full Address'].str.title() + ', ' + gp_practice_df['Postcode'] \n",
    "gp_practice_df['Full Address'] = gp_practice_df['Full Address'].str.replace('Nan', '').str.replace(' ,', ' ')\n",
    "gp_practice_df['Name'] = gp_practice_df['Name'].str.title()\n",
    "gp_practice_df_1 = gp_practice_df[['Organisation Code', 'Name', 'Full Address', 'Postcode', 'Contact Telephone Number']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Geolocation of GP practices in Cambridge using GeoPy and the Nomatin API using their postcodes\n",
    "#-----------------------------------------------------------------------------------------------\n",
    "gp_practice_df_saved = pd.read_csv('data/cambridge_gp_practices.csv', index_col = 0)\n",
    "new_list = list(gp_practice_df_1['Organisation Code'])\n",
    "saved_list = list(gp_practice_df_saved['Organisation Code'])\n",
    "new_orgs = list(set(new_list) - (set(saved_list))) #------------- Geocoding only occurs if new GP practices in Central Cambridge added to the EPRACCUR dataset\n",
    "if new_orgs:\n",
    "    geolocator = Nominatim(user_agent=\"open_access_nhs\") #------------- Setting Nominatim as the API to use during postcode geolocation\n",
    "    geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1) #--------- Rate limiting to 1 query per second\n",
    "    gp_practice_df_1[\"location\"] = gp_practice_df_1[\"Postcode\"].apply(geolocator.geocode)\n",
    "    gp_practice_df_1[\"Point\"] = gp_practice_df_1[\"location\"].apply(lambda loc: tuple(loc.point) if loc else None)\n",
    "    gp_practice_df_1[['Latitude', 'Longitude', 'Altitude']] = gp_practice_df_1['Point'].to_list()\n",
    "    gp_practice_df_2 = gp_practice_df_1[[\"Organisation Code\",\"Name\", \"Full Address\", \"Postcode\", \"Contact Telephone Number\", \"Latitude\", \"Longitude\"]]\n",
    "    gp_practice_df_2.to_csv('data/cambridge_gp_practices.csv') #--------- If new GP practices in the latest EPRACCUR dataset, save a new geocoded Cambridge GP Practice dataset\n",
    "else:\n",
    "    gp_practice_df_2 = gp_practice_df_saved.copy()\n",
    "    print('No new cambridge GP practices')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map visulation of Cambridge GP practices with Postcode area geoJSON\n",
    "#--------------------------------------------------------------------\n",
    "frame = folium.Figure(width=600, height=600)\n",
    "folium_fig = folium.Map(\n",
    "    location=[52.21, 0.15],\n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=12).add_to(frame)\n",
    "\n",
    "#Add markers for each of the Cambridge GP practices with contact and location information added as part of a popup\n",
    "#-----------------------------------------------------------------------------------------------------------------\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['Full 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",
    "\n",
    "#Add a choropleth with the Cambridge postcode areas (with central postcodes differently coloured using the post_code_df)\n",
    "#------------------------------------------------------------------------------------------------------------------------\n",
    "chloro = folium.Choropleth(\n",
    "    geo_data= cam_postcode_shapefile,\n",
    "    data=post_code_df,\n",
    "    name = 'Cambridge Postcodes',\n",
    "    columns= ['Postcode', 'Central Cambridge'],\n",
    "    key_on='feature.properties.name',\n",
    "    fill_color=\"RdBu\",\n",
    "    fill_opacity=0.1,\n",
    "    line_opacity=1,\n",
    "   )\n",
    "for key in chloro._children:\n",
    "    if key.startswith('color_map'):\n",
    "        del(chloro._children[key])\n",
    "chloro.add_to(folium_fig)\n",
    "folium_fig\n",
    "folium.LayerControl().add_to(folium_fig)\n",
    "\n",
    "#Saves the folium map as an html object for use in the webpage\n",
    "#-----------------------------------------------------------------\n",
    "folium_fig.save(\"images/folium/cambridge_map_no_travel.html\", \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Time of travel (walking) analysis for GP practices in central Cambridge (5000 meters from centre)\n",
    "#--------------------------------------------------------------------------------------------------\n",
    "\n",
    "#Create a OSMnx walkable urban network graph 5000 meters point arbitrarily defined as the centre of Cambridge\n",
    "#-------------------------------------------------------------------------------------------------------------\n",
    "place = \"Cambridge, England\"\n",
    "mode = \"walk\"\n",
    "G = ox.graph_from_address(place, dist = 5000, simplify=True, network_type=mode)\n",
    "fig, ax = ox.plot_graph(G, figsize = (15,15));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map the coordinates of each of the central Cambridge GP practices to the nearest node on OSMnx walkable urban network graph\n",
    "#---------------------------------------------------------------------------------------------------------------------------\n",
    "point_of_interest = ox.distance.nearest_nodes(G, X = gp_practice_df_2['Longitude'], Y=gp_practice_df_2['Latitude']) #---- X = longitude, Y = Latitude "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "#Defining trip times of interest, walking speed, and adding and edge attribute 'time' to each edge in urban network graph\n",
    "#---------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "# Trip time in Mintues\n",
    "#----------------------\n",
    "trip_times = [5,10,20]\n",
    "\n",
    "# walking speed in km/hour\n",
    "#-------------------------\n",
    "travel_speed = 4.5\n",
    "\n",
    "# add an edge attribute for time in minutes required to traverse each edge\n",
    "#--------------------------------------------------------------------------\n",
    "meters_per_minute = travel_speed * 1000 / 60 # convert speed in km per hour to meteres per minute as length attribute in edges sorted in metres and travel time specified in minutes\n",
    "for u, v, k, data in G.edges(data=True, keys=True):  \n",
    "    data['time'] = data['length'] / meters_per_minute\n",
    "\n",
    "#---------------\n",
    "# u,v,k refer to the unique indentifiers of an edge in a network graph. u and v are the two nodes the edege connects while the k, is the key attribute which differentiates between parallel edges. \n",
    "# data refers to edge attributes - these include length, osmid, oneway and others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrun one color for each isochrone (each of the trip times) \n",
    "#------------------------------------------------------------\n",
    "iso_colors = ox.plot.get_colors(n=len(trip_times), cmap='YlOrRd', start=0.3, return_hex=True)\n",
    "\n",
    "# Coolor the nodes according to isochrone then plot the urban network graph\n",
    "#--------------------------------------------------------------------------\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(G, points, radius=trip_time, distance='time') #---- uses the edge attribute 'time' to define the isochrones for each of the trips\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 G.nodes()]\n",
    "ns = [10 if node in node_colors else 0 for node in G.nodes()] #------ sets the size of the coloured nodes at '10', while uncoloured nodes (outside trip times) are not visualised\n",
    "fig, ax = ox.plot_graph(G, node_color=nc, node_size=ns, node_alpha=0.8, node_zorder=2, figsize = (15,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate isochrone polygons (convex hull) using GeoPandas and NetworkX for each of the GP practice isochrones \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(G, 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)\n",
    "\n",
    "# Plot the network then add isochrones as colored descartes polygon patches\n",
    "#-----------------------------------------------------------------------\n",
    "fig, ax = ox.plot_graph(G, show=False, close=False, edge_color='k', edge_alpha=0.2, node_color='none', figsize = (15,15))\n",
    "for polygon, fc in zip(isochrone_polys, iso_colors):\n",
    "    for subpolygon in polygon:\n",
    "        patch = PolygonPatch(subpolygon, fc=fc, ec='none', alpha=0.6, zorder=-1)\n",
    "        ax.add_patch(patch)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate three isochrone GeoJSON files representing the areas 5 minutes, 10 minutes, and 20 minutes walking distance from any of the central Cambridge GP practices\n",
    "# from the ischrone polygons and add the to a folium map\n",
    "#-------------------------------------------------------------------------------------------------\n",
    "frame = folium.Figure(width=600, height=600)\n",
    "folium_fig = folium.Map(\n",
    "    location=[52.21, 0.15],\n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=12).add_to(frame)\n",
    "\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['Full 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",
    "\n",
    "#Set the style for each of the ischrone geoJSONs\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",
    "\n",
    "# From each of the isochrone polygons generate at geoJSON shapefile and add it to a folium map at the same time\n",
    "#-------------------------------------------------------------------------------------------------------------\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)\n",
    "folium.LayerControl().add_to(folium_fig)\n",
    "\n",
    "#Saves the folium map as an html object for use in the webpage\n",
    "#--------------------------------------------------------------\n",
    "folium_fig.save(\"images/folium/cambridge_map_travel.html\", \"w\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "292c795e24700ffeb49481d87674b4a2462b1f5926d60159546f48d450d30bc4"
  },
  "kernelspec": {
   "display_name": "Python 3.9.4 64-bit",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}