Cambridge_path.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The first step is to import all the necessary libraries\n",
    "\n",
    "import pandas as pd\n",
    "import geopandas as gpd\n",
    "import folium\n",
    "import osmnx as ox\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import contextily as ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Then loading in the Gowalla Cambridge dataset as a Pandas dataframe\n",
    "df = pd.read_csv('Cambridge_gowalla.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, A new dataframe is being created to include only check-ins by users 75027 and 102829 as that is our target for the first question\n",
    "user_df = df[df['User_ID'].isin([75027, 102829])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting the dataframe to a GeoPandas dataframe to plot on an interactive folium map\n",
    "# Columns lon and lat are the geometry for the dataframe\n",
    "gdf = gpd.GeoDataFrame(user_df, geometry=gpd.points_from_xy(user_df.lon, user_df.lat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the geocode function to obtain the coordinates of Cambridge \n",
    "ox.geocode('Cambridge, UK')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As mentioned earlier, a folium map is generated using the coordinates of Cambridge, with a reasonable zoom level\n",
    "cambridge_coords = [52.2055314, 0.1186637]\n",
    "map = folium.Map(location=cambridge_coords, zoom_start=13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using a loop and the folium.marker function to generate the check in locations on a map\n",
    "# To make the check in points easier to diferentiate, each user's check-ins are marked with different colours\n",
    "for user_id, color in zip([75027, 102829], ['red', 'blue']):\n",
    "    user_gdf = gdf[gdf['User_ID'] == user_id]\n",
    "    for _, row in user_gdf.iterrows():\n",
    "        folium.Marker(location=[row['lat'], row['lon']], icon=folium.Icon(color=color)).add_to(map)\n",
    "\n",
    "# Red here and blue represent the check-in points of users 75027 and 10829 respectively\n",
    "\n",
    "# Finally, the map will be displayed\n",
    "map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new dataframe to include points for user 75027 and only their movements on 30th January 2010\n",
    "user_75027 = df[(df['User_ID'] == 75027) & (df['date'].str.startswith('30/01/2010'))]\n",
    "\n",
    "# Obtaining the address of cambrige\n",
    "graph = ox.graph_from_place('Cambridge, United Kingdom', network_type='all')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = ox.plot_graph(graph, show=False, close=False, edge_color='lightgray', node_color='none', figsize=(8,8))\n",
    "ax.scatter(user_75027['lon'], user_75027['lat'], color='red', zorder=3, s=50)\n",
    "\n",
    "# A loop here defines the start node and end node, where as the route here plots the path between them. This iterates for all the points in the dataframe\n",
    "for i in range(len(user_75027)-1):\n",
    "    start = ox.nearest_nodes(graph, user_75027.iloc[i]['lon'], user_75027.iloc[i]['lat'])\n",
    "    end = ox.nearest_nodes(graph, user_75027.iloc[i+1]['lon'], user_75027.iloc[i+1]['lat'])\n",
    "    route = ox.shortest_path(graph, start, end, weight='length')\n",
    "    \n",
    "    \n",
    "    ox.plot_graph_route(graph, route, ax=ax, route_color='green', route_linewidth=5, node_size=0, show=False, close=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The same steps are repeated for user 10289\n",
    "\n",
    "user_102829 = df[(df['User_ID'] == 102829) & (df['date'].str.startswith('24/05/2010'))]\n",
    "graph = ox.graph_from_place('Cambridge, United Kingdom', network_type='all')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = ox.plot_graph(graph, show=False, close=False, edge_color='lightgray', node_color='none', figsize=(8,8))\n",
    "ax.scatter(user_102829['lon'], user_102829['lat'], color='blue', zorder=3, s=50)\n",
    "\n",
    "\n",
    "for i in range(len(user_102829)-1):\n",
    "    start = ox.nearest_nodes(graph, user_102829.iloc[i]['lon'], user_102829.iloc[i]['lat'])\n",
    "    end = ox.nearest_nodes(graph, user_102829.iloc[i+1]['lon'], user_102829.iloc[i+1]['lat'])\n",
    "    route = ox.shortest_path(graph, start, end, weight='length')\n",
    "    \n",
    "    \n",
    "    ox.plot_graph_route(graph, route, ax=ax, route_color='green', route_linewidth=5, node_size=0, show=False, close=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from geopy.distance import geodesic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new list with the displacement between each consecutive pair of latitude/longitude coordinates using a loop similar to the one made earlier for the shortest path\n",
    "# The geodesic distance here allows the distanfe to be measures in kilometers\n",
    "displacements = []\n",
    "for i in range(1, len(user_75027)):\n",
    "    prev_lat, prev_lon = user_75027.iloc[i-1]['lat'], user_75027.iloc[i-1]['lon']\n",
    "    curr_lat, curr_lon = user_75027.iloc[i]['lat'], user_75027.iloc[i]['lon']\n",
    "    displacement = geodesic((prev_lat, prev_lon), (curr_lat, curr_lon)).km\n",
    "    displacements.append(displacement)\n",
    "\n",
    "# Using the max command on the list provides the maximum displacement value\n",
    "max_displacement = max(displacements)\n",
    "print(f\"Maximum displacement for user 75027 on 30/01/2010 is {max_displacement:.2f} km.\")\n",
    "\n",
    "# The average displacement for the user is calculated by dividing the sum of displacements by the total points\n",
    "avg_displacement = sum(displacements) / len(displacements)\n",
    "print(f\"Average displacement for user 75027 on 30/01/2010 is {avg_displacement:.2f} km.\")\n",
    "\n",
    "# Summing the list gives the total displacement for the user\n",
    "total_displacement = sum(displacements)\n",
    "print(f\"Total displacement for user 75027 on 30/01/2010 is {total_displacement:.2f} km.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The same steps are repeated for user 102829\n",
    "displacements = []\n",
    "for i in range(1, len(user_102829)):\n",
    "    prev_lat, prev_lon = user_102829.iloc[i-1]['lat'], user_102829.iloc[i-1]['lon']\n",
    "    curr_lat, curr_lon = user_102829.iloc[i]['lat'], user_102829.iloc[i]['lon']\n",
    "    displacement = geodesic((prev_lat, prev_lon), (curr_lat, curr_lon)).km\n",
    "    displacements.append(displacement)\n",
    "\n",
    "max_displacement = max(displacements)\n",
    "print(f\"Maximum displacement for user 102829 on 24/05/2010 is {max_displacement:.2f} km.\")\n",
    "\n",
    "avg_displacement = sum(displacements) / len(displacements)\n",
    "print(f\"Average displacement for user 102829 on 24/05/2010 is {avg_displacement:.2f} km.\")\n",
    "\n",
    "total_displacement = sum(displacements)\n",
    "print(f\"Total displacement for user 102829 on 24/05/2010 is {total_displacement:.2f} km.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Repeating the same steps used in the displacement lists above\n",
    "\n",
    "dis2 = []\n",
    "\n",
    "for i in range(len(user_75027) - 1):\n",
    "    # obtaining nearest nodes in the network for the two consecutive points\n",
    "    node1 = ox.nearest_nodes(graph, user_75027.iloc[i]['lon'], user_75027.iloc[i]['lat'])\n",
    "    node2 = ox.nearest_nodes(graph, user_75027.iloc[i + 1]['lon'], user_75027.iloc[i + 1]['lat'])\n",
    "    \n",
    "    # calculating the shortest path length between the two nodes\n",
    "    dis = nx.shortest_path_length(graph, node1, node2, weight='length')\n",
    "    \n",
    "    # appending the calculated maximum displacement to the list\n",
    "    dis2.append(dis)\n",
    "\n",
    "max_displacement = max(dis2)\n",
    "print(f\"Maximum displacement for user 75027 on 30/01/2010 is {max_displacement:.2f} m.\")\n",
    "\n",
    "avg_displacement = sum(dis2) / len(dis2)\n",
    "print(f\"Average displacement for user 75027 on 30/01/2010 is {avg_displacement:.2f} m.\")\n",
    "\n",
    "total_displacement = sum(dis2)\n",
    "print(f\"Total displacement for user 75027 on 30/01/2010 is {total_displacement:.2f} m.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Repeating the same steps for user 102829\n",
    "\n",
    "dis2 = []\n",
    "\n",
    "for i in range(len(user_102829) - 1):\n",
    "    node1 = ox.nearest_nodes(graph, user_102829.iloc[i]['lon'], user_102829.iloc[i]['lat'])\n",
    "    node2 = ox.nearest_nodes(graph, user_102829.iloc[i + 1]['lon'], user_102829.iloc[i + 1]['lat'])\n",
    "    \n",
    "    dis = nx.shortest_path_length(graph, node1, node2, weight='length')\n",
    "    \n",
    "    dis2.append(dis)\n",
    "\n",
    "max_displacement = max(dis2)\n",
    "print(f\"Maximum displacement for user 102829 on 24/05/2010 is {max_displacement:.2f} m.\")\n",
    "\n",
    "avg_displacement = sum(dis2) / len(dis2)\n",
    "print(f\"Average displacement for user 102829 on 24/05/2010 is {avg_displacement:.2f} m.\")\n",
    "\n",
    "total_displacement = sum(dis2)\n",
    "print(f\"Total displacement for user 102829 on 24/05/2010 is {total_displacement:.2f} m.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A multi-graph is obtained using osmnx\n",
    "G=ox.graph_from_place('Cambridge, United Kingdom', network_type='drive')\n",
    "\n",
    "#It is then converted to a digraph\n",
    "DG = ox.get_digraph(G)\n",
    "\n",
    "#Its node centrality is then calculated\n",
    "node_dc = nx.degree_centrality(DG)\n",
    "\n",
    "# The node attributes are then set back to the edge\n",
    "nx.set_node_attributes(DG, node_dc,'dc')\n",
    "\n",
    "# Following which the digraph is converted to a multi-graph\n",
    "G1 = nx.MultiGraph(DG)\n",
    "\n",
    "# The closesness centrality is then calculated using the graph\n",
    "edge_cc = nx.closeness_centrality(nx.line_graph(DG))\n",
    "\n",
    "# And these attributes are set as the edge\n",
    "nx.set_edge_attributes(DG,edge_cc,'cc')\n",
    "G1 = nx.MultiGraph(DG)\n",
    "\n",
    "# This graph is then plotted\n",
    "\n",
    "nc = ox.plot.get_edge_colors_by_attr(G1, 'cc', cmap='plasma')\n",
    "fig, ax = ox.plot_graph(G1, node_size=0, node_color='w', node_edgecolor='gray', node_zorder=2,\n",
    "                        edge_color=nc, edge_linewidth=1.5, edge_alpha=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The graph is then converted to a geodatframe and is assigned a CRS which is rqeuired by contextily to plot a map underneath it\n",
    "gdf_edges = ox.graph_to_gdfs(G1,nodes=False,fill_edge_geometry=True)\n",
    "gdf_edges = gdf_edges.to_crs(epsg=3857) # setting crs to 3857\n",
    "\n",
    "# Edges are then plotted accoridng to degree centrality\n",
    "ax=gdf_edges.plot('cc',cmap='plasma',figsize=(10,10))\n",
    "\n",
    "# A basemap is then added\n",
    "ctx.add_basemap(ax,source=ctx.providers.CartoDB.Positron)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The geometries of the area, in this case the buildings, are obtained using the geometries_from_place function of the osmnx library\n",
    "tags= tags={'amenity': True, 'building':True}\n",
    "all_geom=ox.geometries.geometries_from_place('Cambridge, United Kingdom', tags)\n",
    "all_geom = all_geom.to_crs(epsg=3857)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The first map here plots all buildings in the vicinity, which will be important while examining where to place a fire station later\n",
    "\n",
    "fig,ax = plt.subplots(figsize=(10,10))\n",
    "all_geom[all_geom['building'].notna()].plot(ax=ax,color='black')\n",
    "\n",
    "gdf_edges = ox.graph_to_gdfs(G1, nodes=False, fill_edge_geometry=True)\n",
    "gdf_edges = gdf_edges.to_crs(epsg=3857)\n",
    "\n",
    "ax = gdf_edges.plot('cc', cmap='plasma', figsize=(10, 10), ax=ax)\n",
    "\n",
    "ctx.add_basemap(ax,source=ctx.providers.CartoDB.Positron)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next two maps will represent the buildings in the area and the amenities in the area, from where information regarding residential buildings and the local fire station will be obtained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the buildings and the closness centrality graph on top of each other\n",
    "\n",
    "fig,ax = plt.subplots(figsize=(10,10))\n",
    "all_geom[all_geom['building'].notna()].plot('building',\n",
    "                                            ax=ax,\n",
    "                                            categorical=True,\n",
    "                                            legend=True)\n",
    "\n",
    "gdf_edges = ox.graph_to_gdfs(G1, nodes=False, fill_edge_geometry=True)\n",
    "gdf_edges = gdf_edges.to_crs(epsg=3857)\n",
    "\n",
    "ax = gdf_edges.plot('cc', cmap='plasma', figsize=(10, 10), ax=ax)\n",
    "\n",
    "ctx.add_basemap(ax,source=ctx.providers.CartoDB.Positron)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This code isolates the fire station from the res of the amenities to make it easier to plot\n",
    "fire_station = all_geom[(all_geom['amenity'] == 'fire_station')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boolean indexing to isolate university building\n",
    "# create list of building types to select\n",
    "diff_types = ['apartments', 'dormitory', 'house', 'residential', 'student_residences', 'cabin', 'hotel']\n",
    "fire_station[fire_station['amenity'].notna()].plot('amenity', ax=ax, categorical=True, legend=True)\n",
    "\n",
    "# boolean indexing to select multiple building types\n",
    "housing = all_geom[all_geom['building'].isin(diff_types)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A graph of the selected residential buildings plotted without the centrality graph for better visibility\n",
    "\n",
    "fig,ax = plt.subplots(figsize=(10,10))\n",
    "housing[housing['building'].notna()].plot('building',\n",
    "                                            ax=ax,\n",
    "                                            categorical=True,\n",
    "                                            legend=True)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import contextily as ctx\n",
    "ctx.add_basemap(ax,source=ctx.providers.CartoDB.Positron)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The same graph with centrality\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "housing[housing['building'].notna()].plot('building',\n",
    "                                          ax=ax,\n",
    "                                          categorical=True,\n",
    "                                          legend=True)\n",
    "ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron)\n",
    "\n",
    "gdf_edges = ox.graph_to_gdfs(G1, nodes=False, fill_edge_geometry=True)\n",
    "gdf_edges = gdf_edges.to_crs(epsg=3857)\n",
    "\n",
    "ax = gdf_edges.plot('cc', cmap='plasma', figsize=(10, 10), ax=ax)\n",
    "\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the code to isolate the fire station from earlier, along with a code to plot fire stations in the area on contextily graphs\n",
    "\n",
    "fire_station = all_geom[(all_geom['amenity'] == 'fire_station')]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "fire_station[fire_station['amenity'].notna()].plot('amenity',\n",
    "                                                   ax=ax,\n",
    "                                                   categorical=True,\n",
    "                                                   legend=True)\n",
    "\n",
    "import contextily as ctx\n",
    "ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron, zoom=13)\n",
    "\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As there was only one fire station, this shows the need for adding at least another in order to provided better emergency services in the area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select the desired geometries\n",
    "diff_types = ['apartments', 'dormitory', 'house', 'residential', 'student_residences', 'cabin', 'hotel']\n",
    "buildings = all_geom[all_geom['building'].isin(diff_types)]\n",
    "fire_stations = all_geom[all_geom['amenity'] == 'fire_station']\n",
    "\n",
    "# plot the geometries and add a basemap\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "buildings.plot(column='building', categorical=True, legend=True, ax=ax)\n",
    "fire_stations.plot(ax=ax, color='red', markersize=10)\n",
    "ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron)\n",
    "\n",
    "\n",
    "gdf_edges = ox.graph_to_gdfs(G1, nodes=False, fill_edge_geometry=True)\n",
    "gdf_edges = gdf_edges.to_crs(epsg=3857)\n",
    "\n",
    "ax = gdf_edges.plot('cc', cmap='plasma', figsize=(10, 10), ax=ax)\n",
    "\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a previous map that was produced, which has not been included in the code or report, the address of Cambridge was obtained using the `graph_from_address` function. That resulted in a map which was a fraction of the new map generated and the fire station was barely visible. In the new graph it is not visible at all."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To rectify this problem, the geometries are plotted on a folium map using the `geometries_from_address` function as using the place in general or using a distance of higher than 2500m would result in the kernel crashing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Geometries obtained similarly to earlier\n",
    "small_geom=ox.geometries.geometries_from_address('Cambridge, United Kingdom', tags, dist = 2500)\n",
    "small_geom = small_geom.to_crs(epsg=3857)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The residence buildings and fire station geometries are then added\n",
    "diff_types = ['apartments', 'dormitory', 'house', 'residential', 'student_residences', 'cabin', 'hotel']\n",
    "buildings = small_geom[small_geom['building'].isin(diff_types)]\n",
    "fire_stations = small_geom[small_geom['amenity'] == 'fire_station']\n",
    "\n",
    "# A folium map is created, similar to the one made earlier with geometries added as a GeoJson layer\n",
    "map_cambridge = folium.Map(location=cambridge_coords, zoom_start=12)\n",
    "\n",
    "folium.GeoJson(buildings).add_to(map_cambridge)\n",
    "firestation_style = {'fillColor': 'red', 'color': 'red', 'fillOpacity': 0.7}\n",
    "folium.GeoJson(fire_stations, style_function=lambda x: firestation_style).add_to(map_cambridge)\n",
    "\n",
    "map_cambridge\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ideal place to build a new fire station can be obtained by using NearestNeighbours form the `Sci-kit Learn` library to calculate a point which would suffice and mark it on the folium map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from shapely.geometry import Point\n",
    "\n",
    "# Obtained the cambridge_buildings.geojson file online from OSM\n",
    "json_geom = gpd.read_file(\"cambridge_buildings.geojson\")\n",
    "\n",
    "# Used the same steps as the previous map but with the json_geom file\n",
    "diff_types = ['apartments', 'dormitory', 'house', 'residential', 'student_residences', 'cabin', 'hotel']\n",
    "buildings = json_geom[json_geom['building'].isin(diff_types)]\n",
    "fire_stations = json_geom[json_geom['amenity'] == 'fire_station']\n",
    "\n",
    "map_cambridge = folium.Map(location=cambridge_coords, zoom_start=14)\n",
    "\n",
    "# Importing the NearestNeighbors function from sklearn and numpy\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "import numpy as np\n",
    "\n",
    "# Creating an array from the geometry of the json files to fit in the function\n",
    "X = np.array(list(zip(json_geom.geometry.x, json_geom.geometry.y)))\n",
    "nbrs = NearestNeighbors(n_neighbors=2, algorithm='ball_tree').fit(X)\n",
    "distances, indices = nbrs.kneighbors(X)\n",
    "\n",
    "# Calculating the average distance to the nearest fire station for each building\n",
    "json_geom['avg_distance'] = np.mean(distances[:,1:], axis=1)\n",
    "\n",
    "# Finding the building with the greatest average distance to the fire station\n",
    "best_location = json_geom.loc[json_geom['avg_distance'].idxmax()]\n",
    "\n",
    "# Adding a marker for the ideal location as calculated using NearestNieghbors on the map\n",
    "folium.Marker(\n",
    "    location=[best_location.geometry.y, best_location.geometry.x],\n",
    "    popup=\"Best location for new fire station\",\n",
    "    icon=folium.Icon(color='green'),\n",
    ").add_to(map_cambridge)\n",
    "\n",
    "# display the map\n",
    "map_cambridge\n"
   ]
  }
 ],
 "metadata": {
  "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}