walking_gp_practice_cambridge_lsoa.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Python libraries (use Python >= v. 3.9.0)\n",
    "# ------------------------------------------------\n",
    "\n",
    "import copy\n",
    "import heapq\n",
    "import json\n",
    "import os\n",
    "import urllib.request\n",
    "import zipfile\n",
    "from distutils import dist\n",
    "\n",
    "import branca.colormap as cmp\n",
    "import folium\n",
    "import geojson\n",
    "import geopandas as gpd\n",
    "import ipyleaflet as ipl\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import osmnx as ox\n",
    "import pandas as pd\n",
    "from descartes import PolygonPatch\n",
    "from geopy.extra.rate_limiter import RateLimiter\n",
    "from geopy.geocoders import Nominatim\n",
    "from shapely import geometry\n",
    "from shapely.geometry import shape\n",
    "from shapely.geometry.polygon import Point, Polygon\n",
    "from shapely.ops import unary_union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Cambridge LSOA areas\n",
    "# -------------------------\n",
    "global_lsoa_pd = pd.read_csv('data/lower_layer_super_output_areas_december_2021.csv', header=0, usecols=[0, 1,2, 3], dtype='string')\n",
    "cambridge_lsoa_pd = pd.DataFrame(global_lsoa_pd[global_lsoa_pd['LSOA21NM'].str.contains('Cambridge')])\n",
    "cambridge_lsoa_pd.reset_index(drop=True, inplace=True)\n",
    "cambridge_lsoa_pd['OBJECTID'] = cambridge_lsoa_pd['OBJECTID'].astype(int)\n",
    "cambridge_lsoa_pd['LSOA21CD'] = cambridge_lsoa_pd['LSOA21CD'].astype(str)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Cambrideg LSOA population estimates\n",
    "# ----------------------------------------\n",
    "global_lsoa_population_estimates_2021_pd = pd.read_csv('data/lsoa_global_number_residents_2021.csv',\n",
    "                                                        header=0, \n",
    "                                                        skiprows=9, \n",
    "                                                        names=['LSOA Name', 'LSOA21CD', 'All Ages'], \n",
    "                                                        dtype='string')\n",
    "cambridge_lsoa_population_estimates_pd = pd.DataFrame(global_lsoa_population_estimates_2021_pd[global_lsoa_population_estimates_2021_pd['LSOA Name'].str.contains('Cambridge')])\n",
    "cambridge_lsoa_with_population_pd = pd.merge(cambridge_lsoa_pd, cambridge_lsoa_population_estimates_pd, left_on='LSOA21CD', right_on='LSOA21CD')\n",
    "cambridge_lsoa_with_population_pd['OBJECTID'] = cambridge_lsoa_with_population_pd['OBJECTID'].astype(str)\n",
    "cambridge_lsoa_with_population_pd['All Ages'] = cambridge_lsoa_with_population_pd['All Ages'].str.replace(',', '').astype(int)\n",
    "# print(cambridge_lsoa_with_population_pd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download a geoJSON shapefile for the CB LSOA\n",
    "# --------------------------------------------\n",
    "\n",
    "# Split the LSOA object ids to continuous chunks to load from the arcgis end point\n",
    "# --------------------------------------------------------------------------------\n",
    "object_ids_chunks = [[]]\n",
    "prev_objid = cambridge_lsoa_with_population_pd['OBJECTID'].min()\n",
    "for _, row in cambridge_lsoa_pd.iterrows():\n",
    "    current_objid = row['OBJECTID']\n",
    "    if int(current_objid) - int(prev_objid) > 1:\n",
    "        object_ids_chunks.append([])\n",
    "    object_ids_chunks[-1].append(current_objid)\n",
    "    prev_objid = current_objid\n",
    "\n",
    "# Load the LSOA geofiles from the arcgis and merge into one geogson file for processing\n",
    "# -------------------------------------------------------------------------------------\n",
    "lsoa_shapefile = None\n",
    "for chunk in object_ids_chunks:\n",
    "    cb_geo_json_link =  f\"https://services1.arcgis.com/ESMARspQHYMw9BZ9/arcgis/rest/services/LSOA_2021_EW_BFC_V2/FeatureServer/0/query?where=OBJECTID>={chunk[0]}%20AND%20OBJECTID<={chunk[-1]}&outFields=*&outSR=4326&f=geojson\"\n",
    "    lsoa_shapefile_r = urllib.request.urlopen(cb_geo_json_link)\n",
    "    lsoa_shapefile_all = geojson.loads(lsoa_shapefile_r.read())\n",
    "    if lsoa_shapefile is not None:\n",
    "        lsoa_shapefile['features'] = lsoa_shapefile_all['features'] + lsoa_shapefile['features']\n",
    "    else:\n",
    "        lsoa_shapefile = lsoa_shapefile_all\n",
    "        \n",
    "# Filter LSOAs from Cambridge Only - Loading by OBJECTID could bring additional objects not in Cambridge\n",
    "# ------------------------------------------------------------------------------------------------------\n",
    "remapped_lsoa = copy.deepcopy(lsoa_shapefile)\n",
    "remapped_lsoa['features'] = []\n",
    "for feature in lsoa_shapefile['features']:\n",
    "    row_json = cambridge_lsoa_with_population_pd.loc[cambridge_lsoa_with_population_pd['LSOA21CD'] == feature['properties']['LSOA21CD']].to_dict(orient=\"records\")\n",
    "    if len(row_json):\n",
    "        feature['properties'] =  {**feature['properties'], **row_json[0]}\n",
    "        remapped_lsoa['features'].append(copy.deepcopy(feature))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a folium map visualising the areas covered by the Cambridge LSOAs\n",
    "# ------------------------------------------------------------------------\n",
    "\n",
    "# Defines the highlight and popup style for the choropleth layer\n",
    "# --------------------------------------------------------------\n",
    "linear = cmp.LinearColormap(\n",
    "    ['yellow', 'green', 'blue'],\n",
    "    vmin=600, vmax=3000,\n",
    "    caption='Color Scale for Map' #Caption for Color scale or Legend\n",
    ")\n",
    "\n",
    "style_function = lambda x: {'fillColor': linear(x['properties']['All Ages']), \n",
    "                            'color':'#ffffbf', \n",
    "                            'fillOpacity': 0.03, \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.20, 0.15], \n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=13).add_to(frame)\n",
    "\n",
    "# Add a choropleth with the Cambridge LSOA areas\n",
    "# ----------------------------------------------\n",
    "chloro = folium.Choropleth(\n",
    "    geo_data = remapped_lsoa,\n",
    "    data = cambridge_lsoa_with_population_pd,\n",
    "    name = 'Cambridge LSOA',\n",
    "    columns = ['OBJECTID', 'All Ages'],\n",
    "    key_on='feature.properties.OBJECTID',\n",
    "    fill_color=\"YlGnBu\",\n",
    "    fill_opacity=0.7,\n",
    "    line_opacity=0.2,\n",
    "    highlight = True,\n",
    "    legend_name=\"Population\"\n",
    "   )\n",
    "\n",
    "# Adding a toolip which appears on hover to the postcode choropleth layer\n",
    "# -----------------------------------------------------------------------\n",
    "data_on_hover = folium.features.GeoJson(\n",
    "    data = remapped_lsoa, \n",
    "    style_function=style_function, \n",
    "    highlight_function=highlight_function, \n",
    "    tooltip=folium.features.GeoJsonTooltip(\n",
    "        fields= ['LSOA21NM', 'All Ages'], \n",
    "        aliases=['LSOA Code: ', 'Population: '],\n",
    "        localize = True))\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_lsoa_map.html', \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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) \n",
    "&  gp_practice_df[\"Postcode\"].str.startswith('CB')\n",
    "].reset_index(drop = True)\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 = gp_practice_df[gp_practice_df[\"Full Address\"].str.contains('Cambridge')].reset_index(drop = True)\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": 39,
   "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": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map visulation of Cambridge GP practices with Postcode area geoJSON\n",
    "# -------------------------------------------------------------------\n",
    "frame = folium.Figure(width=500, height=500) #------ Map centred on Cambridge using coordinates\n",
    "cambridge_map = folium.Map(\n",
    "    location=[52.20, 0.15], \n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=13).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(cambridge_map)\n",
    "\n",
    "# Add a choropleth with the Cambridge LSOA areas\n",
    "# ----------------------------------------------\n",
    "chloro = folium.Choropleth(\n",
    "    geo_data = remapped_lsoa,\n",
    "    data = cambridge_lsoa_with_population_pd,\n",
    "    name = 'Cambridge LSOA',\n",
    "    columns = ['OBJECTID', 'All Ages'],\n",
    "    key_on='feature.properties.OBJECTID',\n",
    "    fill_color=\"YlGnBu\",\n",
    "    fill_opacity=0.7,\n",
    "    line_opacity=0.2,\n",
    "    highlight = True,\n",
    "    legend_name=\"Population\"\n",
    "   )\n",
    "\n",
    "# Adding a toolip which appears on hover to the postcode choropleth layer\n",
    "# -----------------------------------------------------------------------\n",
    "data_on_hover = folium.features.GeoJson(\n",
    "    data = remapped_lsoa, \n",
    "    style_function=style_function, \n",
    "    highlight_function=highlight_function, \n",
    "    tooltip=folium.features.GeoJsonTooltip(\n",
    "        fields= ['LSOA21NM', 'All Ages'], \n",
    "        aliases=['LSOA Code: ', 'Population: '],\n",
    "        localize = True))\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_lsoa_map_no_travel.html\", \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time of travel (walking) analysis for GP practices in central Cambridge (10000 meters from centre)\n",
    "# --------------------------------------------------------------------------------------------------\n",
    "\n",
    "# Create a OSMnx walkable urban network graph 10000 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 = 10000, simplify=True, network_type=mode)\n",
    "# fig, ax = ox.plot_graph(G, figsize = (15,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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": 43,
   "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 _, _, _, data in G.edges(data=True, keys=True):  \n",
    "    data['time'] = data['length'] / meters_per_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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 point in point_of_interest:\n",
    "        subgraph = nx.ego_graph(G, point, 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": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For each GP practices generate map of surrounding LSOAs\n",
    "# -------------------------------------------------------\n",
    "practices_to_lsoa_map = {}\n",
    "for index in range(len(point_of_interest)):\n",
    "    practice_code = gp_practice_df_2.iloc[index]['Organisation Code']\n",
    "    practice_long_lat = Point((gp_practice_df_2.iloc[index]['Longitude'], gp_practice_df_2.iloc[index]['Latitude']))\n",
    "    practice_name = gp_practice_df_2.iloc[index]['Name']\n",
    "    practice_nearest_node = point_of_interest[index]\n",
    "    subgraph = nx.ego_graph(G, practice_nearest_node, radius=10, distance='time')\n",
    "    node_points = [Point((data['x'], data['y'])) for _, data in subgraph.nodes(data=True)]\n",
    "    bounding_poly = Polygon(gpd.GeoSeries(node_points).unary_union.convex_hull)\n",
    "    practice_info = {'practice_code' : practice_code, 'practice_name' : practice_name, 'lsoa_codes' : [], 'population' : 0, 'max_walking_time': 0, 'polygons' : []}\n",
    "\n",
    "    # Add mapping between practice and surrounding LSOAs\n",
    "    # --------------------------------------------------\n",
    "    for lsoa in remapped_lsoa['features']:\n",
    "        lsoa_polygon = shape(lsoa['geometry'])\n",
    "        if lsoa_polygon.contains(practice_long_lat) or bounding_poly.intersects(lsoa_polygon):\n",
    "            practice_info['lsoa_codes'].append(lsoa['properties']['LSOA21CD'])\n",
    "            practice_info['population'] = practice_info['population'] + lsoa['properties']['All Ages']\n",
    "            practice_info['polygons'].append(lsoa_polygon)\n",
    "\n",
    "            # Calculate the maximum time walking to the practice from surrounding lsoas\n",
    "            # -------------------------------------------------------------------------\n",
    "            lsoa_boundaries = Polygon(gpd.GeoSeries(lsoa_polygon).unary_union.convex_hull)\n",
    "            distances = [(geometry.LineString([practice_long_lat, v]).length, v) for v in lsoa_boundaries.exterior.coords]\n",
    "            heapq._heapify_max(distances)\n",
    "            _, xy = distances[0]\n",
    "            x, y = xy\n",
    "            max_node = ox.distance.nearest_nodes(G, X = x, Y=y)\n",
    "            walking_distance = nx.shortest_path_length(G, practice_nearest_node, max_node, weight='time')\n",
    "            practice_info['max_walking_time'] = max(practice_info['max_walking_time'], walking_distance)\n",
    "\n",
    "    practices_to_lsoa_map[practice_code] = practice_info\n",
    "\n",
    "# Create one polygon from the surrounding LSOAs\n",
    "# ---------------------------------------------\n",
    "for practice in practices_to_lsoa_map.values():\n",
    "    practice['surrounding'] = unary_union(practice['polygons'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate map of Cambridge LSOAs with interactive markers for each practice. Clicking on the marker will shade the surrounding LSOAs\n",
    "# and will show popup with the total population of the area with maximum walking time to the practice.\n",
    "# -----------------------------------------------------------------------------------------------------------------------------------\n",
    "frame = folium.Figure(width=500, height=500) #------ Map centred on Cambridge using coordinates\n",
    "cambridge_map = folium.Map(\n",
    "    location=[52.20, 0.15], \n",
    "    tiles=\"cartodbpositron\",\n",
    "    zoom_start=13).add_to(frame)\n",
    "\n",
    "map_id = f\"map_{cambridge_map._id}\"\n",
    "marker_handlers = []\n",
    "global_layer = folium.FeatureGroup('Practices Only', show=True)\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",
    "    practice = practices_to_lsoa_map[code]\n",
    "\n",
    "    # Generate selected practice marker\n",
    "    # ---------------------------------\n",
    "    selected_marker = folium.map.Marker(\n",
    "        [lat, lon],\n",
    "        popup = folium.Popup(\n",
    "        f\"<b> Name: </b>{str(name)}<br>\"\n",
    "        f\"<b> GP Practice Code: </b>{str(code)}<br>\"\n",
    "        f\"<b> Address: </b>{str(address)}<br>\"\n",
    "        f\"<b> Telephone Number: </b>{str(number)}<br>\"\n",
    "        f\"<b> Population Estimates: </b>{practice['population']:,}<br>\"\n",
    "        f\"<b> Max walking time to the practice: </b>{practice['max_walking_time']:.0f} mins\",\n",
    "        max_width=len(address)*20),\n",
    "        icon=folium.Icon(color=\"red\", prefix='fa', icon=\"fa-medkit\"))\n",
    "    \n",
    "    geojson = gpd.GeoSeries(practice['surrounding']).unary_union\n",
    "    shape_name = f\"{practice['practice_code']}: {practice['practice_name']}\"\n",
    "    fillColor = '#003087'\n",
    "    area = 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",
    "        })\n",
    "    \n",
    "    # Generate the layer of selected practice with surrounding LSOAs\n",
    "    # --------------------------------------------------------------\n",
    "    layer = folium.FeatureGroup(shape_name, show=False)\n",
    "    layer.add_child(selected_marker)\n",
    "    layer.add_child(area)\n",
    "    layer.add_to(cambridge_map)\n",
    "    \n",
    "    # Generate unselected markers for GP practices\n",
    "    # --------------------------------------------\n",
    "    unselected_marker = folium.map.Marker(\n",
    "        [lat, lon],\n",
    "        popup = folium.Popup(\n",
    "        f\"<b> Name: </b>{str(name)}<br>\"\n",
    "        f\"<b> GP Practice Code: </b>{str(code)}<br>\"\n",
    "        f\"<b> Address: </b>{str(address)}<br>\"\n",
    "        f\"<b> Telephone Number: </b>{str(number)}<br>\"\n",
    "        f\"<b> Population Estimates: </b>{practice['population']:,}<br>\"\n",
    "        f\"<b> Max walking time to the practice: </b>{practice['max_walking_time']:.0f} mins\",\n",
    "        max_width=len(address)*20),\n",
    "        icon=folium.Icon(color=\"darkblue\", prefix='fa', icon=\"fa-medkit\"))\n",
    "    global_layer.add_child(unselected_marker)\n",
    "    \n",
    "    # Generate click handlers for the page to select and unselect the GP practices with surrounding LSOAs\n",
    "    # ---------------------------------------------------------------------------------------------------\n",
    "    marker_handlers.append(f\"marker_{unselected_marker._id}.on('click', function() {{ feature_group_{layer._id}.addTo({map_id}); }});\")\n",
    "    marker_handlers.append(f\"marker_{selected_marker._id}.on('click', function() {{ feature_group_{layer._id}.remove(); }});\")\n",
    "    \n",
    "global_layer.add_to(cambridge_map)\n",
    "\n",
    "# Add a choropleth with the Cambridge LSOA areas\n",
    "# ----------------------------------------------\n",
    "chloro = folium.Choropleth(\n",
    "    geo_data = remapped_lsoa,\n",
    "    data = cambridge_lsoa_with_population_pd,\n",
    "    name = 'Cambridge LSOA',\n",
    "    columns = ['OBJECTID', 'All Ages'],\n",
    "    key_on='feature.properties.OBJECTID',\n",
    "    fill_color=\"YlGnBu\",\n",
    "    fill_opacity=0.7,\n",
    "    line_opacity=0.2,\n",
    "    highlight = True,\n",
    "    legend_name=\"Population\"\n",
    "   )\n",
    "\n",
    "# Adding a toolip which appears on hover to the postcode choropleth layer\n",
    "# -----------------------------------------------------------------------\n",
    "data_on_hover = folium.features.GeoJson(\n",
    "    data = remapped_lsoa, \n",
    "    style_function=style_function, \n",
    "    highlight_function=highlight_function, \n",
    "    tooltip=folium.features.GeoJsonTooltip(\n",
    "        fields= ['LSOA21NM', 'All Ages'], \n",
    "        aliases=['LSOA Code: ', 'Population: '],\n",
    "        localize = True))\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_lsoa_map_travel.html\")\n",
    "\n",
    "# Adds the click handlers to the map\n",
    "# ----------------------------------\n",
    "with open (\"images/folium/cambridge_lsoa_map_travel.html\", 'r') as f:\n",
    "    lines = f.readlines()\n",
    "\n",
    "for action_handler in marker_handlers:\n",
    "    lines.insert(-1, action_handler)\n",
    "\n",
    "with open (\"images/folium/cambridge_lsoa_map_travel.html\", 'w') as f:\n",
    "    text = \"\\n\".join(lines)\n",
    "    f.write(text)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "47eba09898b3eb7e9a91f714e58e3aaf64d5f9ec9b7442d8904d3fa60ccaaff9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}