notebooks/06-example-osmnx-networkx.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use OSMnx to analyze a NetworkX street network, including routing\n",
    "\n",
    "Author: [Geoff Boeing](https://geoffboeing.com/)\n",
    "\n",
    "  - [Overview of OSMnx](http://geoffboeing.com/2016/11/osmnx-python-street-networks/)\n",
    "  - [GitHub repo](https://github.com/gboeing/osmnx)\n",
    "  - [Examples, demos, tutorials](https://github.com/gboeing/osmnx-examples)\n",
    "  - [Documentation](https://osmnx.readthedocs.io/en/stable/)\n",
    "  - [Journal article/citation](http://geoffboeing.com/publications/osmnx-complex-street-networks/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.cm as cm\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import osmnx as ox\n",
    "import pandas as pd\n",
    "%matplotlib inline\n",
    "ox.config(log_console=True, use_cache=True)\n",
    "ox.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate basic street network measures (topological and metric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the network for Piedmont, calculate its basic stats, then show the average circuity\n",
    "stats = ox.basic_stats(ox.graph_from_place('Piedmont, California, USA'))\n",
    "stats['circuity_avg']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To calculate density-based metrics, you must also pass the network's bounding area in square meters (otherwise basic_stats() will just skip them in the calculation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the street network for a place, and its area in square meters\n",
    "place = 'Piedmont, California, USA'\n",
    "gdf = ox.gdf_from_place(place)\n",
    "area = ox.project_gdf(gdf).unary_union.area\n",
    "G = ox.graph_from_place(place, network_type='drive_service')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate basic and extended network stats, merge them together, and display\n",
    "stats = ox.basic_stats(G, area=area)\n",
    "extended_stats = ox.extended_stats(G, ecc=True, bc=True, cc=True)\n",
    "for key, value in extended_stats.items():\n",
    "    stats[key] = value\n",
    "pd.Series(stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Streets/intersection counts and proportions are nested dicts inside the stats dict. To convert these stats to a pandas dataframe (to compare/analyze multiple networks against each other), just unpack these nested dicts first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unpack dicts into individiual keys:values\n",
    "stats = ox.basic_stats(G, area=area)\n",
    "for k, count in stats['streets_per_node_counts'].items():\n",
    "    stats['int_{}_count'.format(k)] = count\n",
    "for k, proportion in stats['streets_per_node_proportion'].items():\n",
    "    stats['int_{}_prop'.format(k)] = proportion\n",
    "\n",
    "# delete the no longer needed dict elements\n",
    "del stats['streets_per_node_counts']\n",
    "del stats['streets_per_node_proportion']\n",
    "\n",
    "# load as a pandas dataframe\n",
    "pd.DataFrame(pd.Series(stats)).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inspect betweenness centrality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G_projected = ox.project_graph(G)\n",
    "max_node, max_bc = max(extended_stats['betweenness_centrality'].items(), key=lambda x: x[1])\n",
    "max_node, max_bc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the city of Piedmont, California, the node with the highest betweenness centrality has 29.4% of all shortest paths running through it. Let's highlight it in the plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nc = ['r' if node==max_node else '#336699' for node in G_projected.nodes()]\n",
    "ns = [50 if node==max_node else 8 for node in G_projected.nodes()]\n",
    "fig, ax = ox.plot_graph(G_projected, node_size=ns, node_color=nc, node_zorder=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "29.4% of all shortest paths run through the node highlighted in red. Let's look at the relative betweenness centrality of every node in the graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get a color for each node\n",
    "def get_color_list(n, color_map='plasma', start=0, end=1):\n",
    "    return [cm.get_cmap(color_map)(x) for x in np.linspace(start, end, n)]\n",
    "\n",
    "def get_node_colors_by_stat(G, data, start=0, end=1):\n",
    "    df = pd.DataFrame(data=pd.Series(data).sort_values(), columns=['value'])\n",
    "    df['colors'] = get_color_list(len(df), start=start, end=end)\n",
    "    df = df.reindex(G.nodes())\n",
    "    return df['colors'].tolist()\n",
    "\n",
    "nc = get_node_colors_by_stat(G_projected, data=extended_stats['betweenness_centrality'])\n",
    "fig, ax = ox.plot_graph(G_projected, node_color=nc, node_edgecolor='gray', node_size=20, node_zorder=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, the nodes are visualized by betweenness centrality, from low (dark violet) to high (light yellow)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Routing: calculate the network path from the centermost node to some other node\n",
    "Let the origin node be the node nearest the location and let the destination node just be the last node in the network. Then find the shortest path between origin and destination, using weight='length' to find the shortest spatial path (otherwise it treats each edge as weight=1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a lat-long point, create network around point, define origin/destination nodes\n",
    "location_point = (37.791427, -122.410018)\n",
    "G = ox.graph_from_point(location_point, distance=500, distance_type='network', network_type='walk')\n",
    "origin_node = ox.get_nearest_node(G, location_point)\n",
    "destination_node = list(G.nodes())[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the route between these nodes then plot it\n",
    "route = nx.shortest_path(G, origin_node, destination_node)\n",
    "fig, ax = ox.plot_graph_route(G, route)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# project the network to UTM (zone calculated automatically) then plot the network/route again\n",
    "G_proj = ox.project_graph(G)\n",
    "fig, ax = ox.plot_graph_route(G_proj, route)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Routing: plot network path from one lat-long to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define origin/desination points then get the nodes nearest to each\n",
    "origin_point = (37.792896, -122.412325)\n",
    "destination_point = (37.790495, -122.408353)\n",
    "origin_node = ox.get_nearest_node(G, origin_point)\n",
    "destination_node = ox.get_nearest_node(G, destination_point)\n",
    "origin_node, destination_node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the shortest path between origin and destination nodes\n",
    "route = nx.shortest_path(G, origin_node, destination_node, weight='length')\n",
    "str(route)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot the route showing origin/destination lat-long points in blue\n",
    "fig, ax = ox.plot_graph_route(G, route, origin_point=origin_point, destination_point=destination_point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demonstrate routing with one-way streets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = ox.graph_from_address('N. Sicily Pl., Chandler, Arizona', distance=800, network_type='drive')\n",
    "origin = (33.307792, -111.894940)\n",
    "destination = (33.312994, -111.894998)\n",
    "origin_node = ox.get_nearest_node(G, origin)\n",
    "destination_node = ox.get_nearest_node(G, destination)\n",
    "route = nx.shortest_path(G, origin_node, destination_node)\n",
    "fig, ax = ox.plot_graph_route(G, route, save=True, filename='route')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Also, when there are parallel edges between nodes in the route, OSMnx picks the shortest edge to plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "location_point = (33.299896, -111.831638)\n",
    "G = ox.graph_from_point(location_point, distance=500, clean_periphery=False)\n",
    "origin = (33.301821, -111.829871)\n",
    "destination = (33.301402, -111.833108)\n",
    "origin_node = ox.get_nearest_node(G, origin)\n",
    "destination_node = ox.get_nearest_node(G, destination)\n",
    "route = nx.shortest_path(G, origin_node, destination_node)\n",
    "fig, ax = ox.plot_graph_route(G, route)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python (ox)",
   "language": "python",
   "name": "ox"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}