{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "jTmaE4gi47C9"
},
"source": [
"# Tutorial 1: Working with OpenStreetMap\n",
"\n",
"Within this tutorial, we will explore the power of OpenStreetMap. We will learn how to extract information from OpenStreetMap, how you can explore and visualize this, and how to use it for some basic analysis.\n",
"\n",
"### Important before we start\n",
"---\n",
"Make sure that you save this file before you continue, else you will lose everything. To do so, go to **Bestand/File** and click on **Een kopie opslaan in Drive/Save a Copy on Drive**!\n",
"\n",
"Now, rename the file into Week5_Tutorial1.ipynb. You can do so by clicking on the name in the top of this screen."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KqMg54GZ47DB",
"tags": []
},
"source": [
"## Learning Objectives\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "JC0K9vub47DC"
},
"source": [
"- To understand the use of **OSMnx** to extract geospatial data from OpenStreetmap.\n",
"- To know how to rasterize vector data through using **Geocube**.\n",
"- To know how to visualise vector and raster data.\n",
"- To understand the basic functioning of **Matplotlib** to create a map.\n",
"- To know how one can generate routes between two points using **NetworkX**.\n",
"- To visualize networks on an interactive map."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "W6efV5lD47DC"
},
"source": [
"Tutorial Outline
\n",
"
\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "xVGN7_hz47DD",
"tags": []
},
"source": [
"## 1.Introducing the packages\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mr4J-7kq47DD"
},
"source": [
"Within this tutorial, we are going to make use of the following packages: \n",
"\n",
"[**GeoPandas**](https://geopandas.org/) is a Python package that extends the datatypes used by pandas to allow spatial operations on geometric types.\n",
"\n",
"[**OSMnx**](https://osmnx.readthedocs.io/) is a Python package that lets you download geospatial data from OpenStreetMap and model, project, visualize, and analyze real-world street networks and any other geospatial geometries. You can download and model walkable, drivable, or bikeable urban networks with a single line of Python code then easily analyze and visualize them. You can just as easily download and work with other infrastructure types, amenities/points of interest, building footprints, elevation data, street bearings/orientations, and speed/travel time.\n",
"\n",
"[**NetworkX**](https://networkx.org/) is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks.\n",
"\n",
"[**Matplotlib**](https://matplotlib.org/) is a comprehensive Python package for creating static, animated, and interactive visualizations in Python. Matplotlib makes easy things easy and hard things possible.\n",
"\n",
"[**Geocube**](https://corteva.github.io/geocube) is a Python package to convert geopandas vector data into rasterized data.\n",
"\n",
"[**xarray**](https://docs.xarray.dev/) is a Python package that allows for easy and efficient use of multi-dimensional arrays.\n",
"\n",
"*We will first need to install these packages in the cell below. Uncomment them to make sure we can pip install them*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 31325,
"status": "ok",
"timestamp": 1675086280074,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "VD7sW5hx47DE",
"outputId": "36a15ed9-7936-4f89-9284-6562c265d75c"
},
"outputs": [],
"source": [
"!pip install osmnx\n",
"!pip install geocube\n",
"!pip install contextily"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eVsADIc847DG"
},
"source": [
"Now we will import these packages in the cell below:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 3237,
"status": "ok",
"timestamp": 1675086283294,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "EJeE3bc047DG"
},
"outputs": [],
"source": [
"import warnings\n",
"warnings.filterwarnings('ignore') \n",
"\n",
"import osmnx as ox\n",
"import numpy as np\n",
"import networkx as nx\n",
"import contextily as cx\n",
"import matplotlib\n",
"import geopandas as gpd\n",
"\n",
"from matplotlib.colors import LinearSegmentedColormap,ListedColormap\n",
"from matplotlib.patches import Patch\n",
"import matplotlib.pyplot as plt\n",
"from geocube.api.core import make_geocube\n",
"from urllib import request\n",
"\n",
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YPgVj6al47DH"
},
"source": [
"## 2. Extract and visualize land-use information from OpenStreetMap\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Uhh94J5Z47DI"
},
"source": [
"The first step is to define which area you want to focus on. In the cell below, you will now read \"Zoeterwoude, The Netherlands\". Change this to any area or municipality in the Netherlands that (1) you can think of and (2) will work. \n",
"\n",
"In some cases, the function does not recognize the location. You could either try a different phrasing or try a different location. Many parts of the Netherlands should work."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"executionInfo": {
"elapsed": 1398,
"status": "ok",
"timestamp": 1675086381517,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "9cijX5J047DI"
},
"outputs": [],
"source": [
"place_name = \"Zoeterwoude, The Netherlands\"\n",
"area = ox.geocode_to_gdf(place_name)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kX3feV7O47DJ"
},
"source": [
"Now let us visualize the bounding box of the area. As you will notice, we also estimate the size of the area. If the area size is above 50km2, or when you have many elements within your area (for example the amsterdam city centre), extracting the data from OpenStreetMap may take a little while. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 608
},
"executionInfo": {
"elapsed": 5155,
"status": "ok",
"timestamp": 1675086404602,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "JFBsptnt47DJ",
"outputId": "3a628a04-9ade-43dd-f684-efae51795dc5",
"tags": []
},
"outputs": [],
"source": [
"area_to_check = area.to_crs(epsg=3857)\n",
"ax = area_to_check.plot(figsize=(10, 10), color=\"none\", edgecolor=\"k\", linewidth=4)\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()\n",
"cx.add_basemap(ax, zoom=11)\n",
"\n",
"size = int(area_to_check.area/1e6)\n",
"\n",
"ax.set_title(\"{}. Total area: {} km2\".format(place_name,size),fontweight='bold')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pT5odIz-6fki"
},
"source": [
"\n",
"Question 1: To make sure we understand which area you focus on, please submit the figure that outlines your area.\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6zbwxAev47DL"
},
"source": [
"Now we are satisfied with the selected area, we are going to extract the land-use information from OpenStreetMap. To find the right information from OpenStreetMap, we use **tags**.\n",
"\n",
"As you will see in the cell below, we use the tags *\"landuse\"* and *\"natural\"*. We need to use the *\"natural\"* tag to ensure we also obtain water bodies and other natural elements. "
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"executionInfo": {
"elapsed": 104940,
"status": "ok",
"timestamp": 1675086538272,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "pWxGFjgN47DL"
},
"outputs": [],
"source": [
"tags = {'landuse': True, 'natural': True} \n",
"landuse = ox.features_from_place(place_name, tags)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In case the above does not work, you can continue the assignment by using the code below (make sure you remove the hashtags to run it). If you decide to use the data as specified below, also change the map at the start to 'Kampen'."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [],
"source": [
"# remote_url = 'https://github.com/ElcoK/BigData_AED/raw/main/week5/kampen_landuse.gpkg'\n",
"# file = 'kampen_landuse.gpkg'\n",
"\n",
"# request.urlretrieve(remote_url, file)\n",
"#landuse = gpd.GeoDataFrame.from_file('kampen_landuse.gpkg')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "brNqZmi547DM"
},
"source": [
"To ensure we really only get the area that we want, we use geopandas's `clip` function to only keep the area we want. This function does exactly the same as the `clip` function in QGIS."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Anrn7wiL47DM"
},
"source": [
"When we want to visualize or analyse the data, we want all information in a single column. However, at the moment, all information that was tagged as *\"natural\"*, has no information stored in the *\"landuse\"* tags. It is, however, very convenient if we can just use a single column for further exploration of the data. \n",
"\n",
"To overcome this issue, we need to add the missing information to the landuse column, as done below. Let's first have a look which categories we have in the **natural** column. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"landuse.natural.unique()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And now we can add them to the **landuse** column. We made a start, but its up to you to fill in the rest."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"executionInfo": {
"elapsed": 429,
"status": "ok",
"timestamp": 1675086633493,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "nlyHmEzg47DM"
},
"outputs": [],
"source": [
"landuse.loc[landuse.natural=='water','landuse'] = 'water'\n",
"landuse.loc[landuse.natural=='wetland','landuse'] = 'wetlands'\n",
"\n",
"\n",
"landuse = landuse.dropna(subset=['landuse'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FOhhcbFs8Nsz"
},
"source": [
"\n",
"Question 2: Please provide in the answer box in Canvas the code that you used to make sure that all land uses are now registered within the landuse column.\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Ii4rjR3q47DN"
},
"source": [
"Our next step is to prepare the visualisation of a map. What better way to explore land-use information than plotting it on a map? \n",
"\n",
"As you will see below, we can create a dictionary with color codes that will color each land-use class based on the color code provided in this dictionary."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"executionInfo": {
"elapsed": 864,
"status": "ok",
"timestamp": 1675086777083,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "urAI5MAG47DN"
},
"outputs": [],
"source": [
"color_dict = { \"grass\":'#c3eead', \"railway\": \"#000000\",\n",
" \"forest\":'#1c7426', \"orchard\":'#fe6729',\n",
" \"residential\":'#f13013', \"industrial\":'#0f045c',\n",
" \"retail\":'#b71456', \"education\":'#d61181', \n",
" \"commercial\":'#981cb8', \"farmland\":'#fcfcb9',\n",
" \"cemetery\":'#c39797', \"construction\":'#c0c0c0',\n",
" \"meadow\":'#c3eead', \"farmyard\":'#fcfcb9',\n",
" \"plant_nursery\":'#eaffe2', \"scrub\":'#98574d',\n",
" \"allotments\":'#fbffe2', \"reservoir\":'#8af4f2',\n",
" \"static_caravan\":'#ff3a55', \"wetlands\": \"#c9f5e5\",\n",
" \"water\": \"#c9e5f5\", \"beach\": \"#ffeead\",\n",
" \"landfill\" : \"#B08C4D\", \"recreation_ground\" : \"#c3eead\",\n",
" \"brownfield\" : \"#B08C4D\", \"village_green\" : \"#f13013\" ,\n",
" \"military\": \"#52514E\", \"garden\" : '#c3eead'\n",
" } "
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Daf-4BMa47DN"
},
"source": [
"Unfortunately, OpenSteetMap very often contains elements that have a unique tag. As such, it may be the case that some of our land-use categories are not in the dictionary yet. \n",
"\n",
"Let's first create an overview of the unique land-use categories within our data through using the `.unique()` function within our dataframe:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 221,
"status": "ok",
"timestamp": 1675086893656,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "h8t5a6_Z47DN",
"outputId": "9e17ba91-d0a4-4dcc-df05-8483f352a228"
},
"outputs": [],
"source": [
"landuse.landuse.unique()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "h0p7fYBd47DN"
},
"source": [
"Ofcourse we can visually compare the array above with our color_dict, but it is much quicker to use `Sets` to check if there is anything missing:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 248,
"status": "ok",
"timestamp": 1675086896661,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "UZaHsgNq47DO",
"outputId": "8a7f6f9e-8bde-4c5c-8012-6ed7f8b071ed"
},
"outputs": [],
"source": [
"set(landuse.landuse.unique())-set(color_dict)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EtMHGvQk47DO"
},
"source": [
"In case anything is missing, add them to the color_dict dictionairy and re-run that cell. \n",
"\n",
"\n",
"Question 3: Show us in Canvas (i) which land-use categories you had to add, and (ii) how your final color dictionary looks like.\n",
"
\n",
"\n",
"```{tip}\n",
"You can easily find hexcodes online to find the right colour for each land-use category. Just google hexcodes!\n",
"```\n",
"\n",
"\n",
"Our next step is to make sure that we can connect our color codes to our dataframe with land-use categories."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 208,
"status": "ok",
"timestamp": 1675086997214,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "Fkkqz3Px47DO"
},
"outputs": [],
"source": [
"color_dict = {key: color_dict[key]\n",
" for key in color_dict if key not in list(set(color_dict)-set(landuse.landuse.unique()))}\n",
"\n",
"map_dict = dict(zip(color_dict.keys(),[x for x in range(len(color_dict))]))\n",
"\n",
"landuse['col_landuse'] = landuse.landuse.apply(lambda x: color_dict[x])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "NxWuztp347DO"
},
"source": [
"Now we can plot the figure!\n",
"\n",
"As you will see in the cell below, we first state that we want to create a figure with a specific figure size. You can change the dimensions to your liking."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 608
},
"executionInfo": {
"elapsed": 1825,
"status": "ok",
"timestamp": 1675087046285,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "NH6j-qJ147DO",
"outputId": "23c77638-0509-4bb3-dc19-904f586b2a70"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(12,10))\n",
"\n",
"# add color scheme\n",
"color_scheme_map = list(color_dict.values())\n",
"cmap = LinearSegmentedColormap.from_list(name='landuse',\n",
" colors=color_scheme_map) \n",
"\n",
"# and plot the land-use map.\n",
"landuse.plot(color=landuse['col_landuse'],ax=ax,linewidth=0)\n",
"\n",
"# remove the ax labels\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()\n",
"\n",
"# add a legend:\n",
"legend_elements = []\n",
"for iter_,item in enumerate(color_dict):\n",
" legend_elements.append(Patch(facecolor=color_scheme_map[iter_],label=item)) \n",
"\n",
"ax.legend(handles=legend_elements,edgecolor='black',facecolor='#fefdfd',prop={'size':12},loc=(1.02,0.2)) \n",
"\n",
"# add a title\n",
"ax.set_title(place_name,fontweight='bold')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EGwHPQEL9_hD"
},
"source": [
"\n",
"Question 4: Please upload a figure of your land-use map, using OpenStreetMap. \n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EzQP70Om47DO"
},
"source": [
"## 3. Rasterize land-use information\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4w-Py4fw47DP"
},
"source": [
"As you have noticed already during the lecture, and as we will again see next week when using the Google Earth Engine, most land-use data is in raster format. \n",
"\n",
"In OpenStreetMap everything is stored in vector format. As such, the land-use information we extracted from OpenStreetMap is also in vector format. While it is not always necessary to have this information in raster format, it is useful to know how to convert your data into a raster format.\n",
"\n",
"To do so, we can make use of the **GeoCube** package, which is a newly developed Python package that can very easily convert vector data into a raster format."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PXETqUIN47DP"
},
"source": [
"The first thing we will need to do is to define all the unique land-use classes and store them in a dictionary:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 290,
"status": "ok",
"timestamp": 1675087253309,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "4st7ApDp47DP"
},
"outputs": [],
"source": [
"categorical_enums = {'landuse': landuse.landuse.drop_duplicates().values.tolist()\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4_qzExh447DP"
},
"source": [
"And now we simply use the `make_geocube()` function to convert our vector data into raster data. \n",
"\n",
"In the `make_geocube()` function, we have to specify several arguments:\n",
"\n",
"- Through the `vector_data` argument we have to state which dataframe we want to rasterize.\n",
"- Through the `output_crs` argument we have to state the coordinate reference system (CRS). We use the OpenStreetMap default EPSG:4326.\n",
"- Through the `resolution` argument we have to state the resolution. In our case, we will have to set this in degrees. 0.01 degrees is equivalent to roughly 10km around the equator. \n",
"- Through the `categorical_enums` argument we specify the different land-use categories.\n",
"\n",
"Play around with the different resolutions to find the level of detail. The higher the resolution (i.e., the more zeros behind the comma), the longer it will take to rasterize."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 551,
"status": "ok",
"timestamp": 1675087257707,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "wjGoNrwg47DP",
"tags": []
},
"outputs": [],
"source": [
"landuse_grid = make_geocube(\n",
" vector_data=XXXX,\n",
" output_crs=\"epsg:4326\",\n",
" resolution=(-XXXX, XXXX),\n",
" categorical_enums=categorical_enums\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wx4FAAsg47DP"
},
"source": [
"Let's explore what this function has given us:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 389
},
"executionInfo": {
"elapsed": 429,
"status": "ok",
"timestamp": 1675087480922,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "JqdlWZUe47DQ",
"outputId": "8880c112-9200-4613-ef45-01e8b88c0bde"
},
"outputs": [],
"source": [
"landuse_grid[\"landuse\"]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "UB4gbheF47DQ"
},
"source": [
"The output above is a typical output of the **xarray** package. \n",
"\n",
"- The `array` shows the numpy array with the actual values. As you can see, the rasterization process has used the value `-1` for NoData. \n",
"- The `Coordinates` table shows the x (longitude) and y (latitude) coordinates of the array. It has the exact same size as the `array` with land-use values.\n",
"- The `Attributes` table specifies the NoData value (the `_FillValue` element, which indeed shows `-1`) and the name of the dataset.\n",
"\n",
"Now let's plot the data to see the result!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 608
},
"executionInfo": {
"elapsed": 1852,
"status": "ok",
"timestamp": 1675087494788,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "extRLk1W47DQ",
"outputId": "19fe91a4-5785-494e-a370-9408a563a70a"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(14,10))\n",
"\n",
"landuse_grid[\"landuse\"].plot(ax=ax,vmin=0,vmax=15,levels=15,cmap='tab20')\n",
"\n",
"# remove the ax labels\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()\n",
"\n",
"#add a title\n",
"\n",
"ax.set_title('')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "94GLYG5K47DQ"
},
"source": [
"As we can see in the figure above, the land-use categories have turned into numbers, instead of land-use categories described by a string value. \n",
"\n",
"This is of course a lot harder to interpret. Let's re-do some parts to make sure we can properly link them back to the original data.\n",
"\n",
"To do so, we will first need to make sure that we know which values (numbers) are connected to each land-use category. Instead of trying to match, let's predefine this ourselves!\n",
"\n",
"We will start with creating a dictionary that allows us to couple a number to each category:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 209,
"status": "ok",
"timestamp": 1675087654241,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "iSHZ4nq247DQ"
},
"outputs": [],
"source": [
"value_dict = dict(zip(landuse.landuse.unique(),np.arange(0,len(landuse.landuse.unique()),1)))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 2,
"status": "ok",
"timestamp": 1675087655102,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "ZCng7Xyk47DQ"
},
"outputs": [],
"source": [
"value_dict['nodata'] = -1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zv1-QoKv47DR"
},
"source": [
"And we now use this dictionary to add a new column to the dataframe with the values:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 904,
"status": "ok",
"timestamp": 1675087658329,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "9c2byjZn47DR"
},
"outputs": [],
"source": [
"landuse['landuse_value'] = landuse.landuse.apply(lambda x: value_dict[x])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FP4pzj2A47DR"
},
"source": [
"Now let us use the `make_geocube()` function again to rasterize."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 1101,
"status": "ok",
"timestamp": 1675087662054,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "Z-1RmkFC47DR"
},
"outputs": [],
"source": [
"landuse_valued = make_geocube(\n",
" vector_data=XXXX,\n",
" output_crs=XXXX,\n",
" resolution=(-XXXX, XXXX),\n",
" categorical_enums={'landuse_value': landuse.landuse_value.drop_duplicates().values.tolist()\n",
"}\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "V0-NKtL147DR"
},
"source": [
"And let's use the original `color_dict` dictionary to find the right hex codes for each of the land-use categories"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 227,
"status": "ok",
"timestamp": 1675087671651,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "4FKdnZ4V47DR"
},
"outputs": [],
"source": [
"unique_classes = landuse.landuse.drop_duplicates().values.tolist()\n",
"colormap_raster = [color_dict[lu_class] for lu_class in unique_classes] "
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "be1TcNAK47DR"
},
"source": [
"To plot the new result:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 608
},
"executionInfo": {
"elapsed": 1116,
"status": "ok",
"timestamp": 1675087675785,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "qBo9kmWy47DR",
"outputId": "269fe715-c71f-4f82-ca71-021b67a3ccf7"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(14,10))\n",
"\n",
"landuse_valued[\"landuse_value\"].plot(ax=ax,vmin=0,vmax=19,levels=len(unique_classes),colors=colormap_raster)\n",
"\n",
"# remove the ax labels\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()\n",
"\n",
"# add title\n",
"ax.set_title('')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "cO2YPNMU-9hQ"
},
"source": [
"\n",
"Question 5: In the rasterization process, we use the `.make_geocube()` function. Please elaborate on the following: i)why is it important to specify the right coordinate system? What could happen if you choose the wrong coordinate system? ii) which resolution did you choose and why? iii)Why did the first result did not give us the right output with the correct colors? How did you solve this? \n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "dx5ZK8Vm47DS"
},
"source": [
"But to be honest, this legend is still not entirely what we are looking for. So let's do some Python magic to get a legend like we desire when plotting a land-use map"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 242,
"status": "ok",
"timestamp": 1675087680453,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "plSLRJp947DS"
},
"outputs": [],
"source": [
"unique_classes = landuse.landuse.drop_duplicates().values.tolist()\n",
"colormap_raster = [color_dict[lu_class] for lu_class in unique_classes] \n",
"color_dict_raster = dict(zip(np.arange(-1,len(landuse.landuse.unique())+1,1),['#ffffff']+colormap_raster))\n",
"\n",
"# We create a colormar from our list of colors\n",
"cm = ListedColormap([color_dict_raster[x] for x in color_dict_raster.keys()])\n",
"\n",
"# Let's also define the description of each category. Order should be respected here!\n",
"labels = np.array(['nodata'] + unique_classes)\n",
"len_lab = len(labels)\n",
"\n",
"# prepare normalizer\n",
"## Prepare bins for the normalizer\n",
"norm_bins = np.sort([*color_dict_raster.keys()]) + 0.5\n",
"norm_bins = np.insert(norm_bins, 0, np.min(norm_bins) - 1.0)\n",
"\n",
"## Make normalizer and formatter\n",
"norm = matplotlib.colors.BoundaryNorm(norm_bins, len_lab, clip=True)\n",
"fmt = matplotlib.ticker.FuncFormatter(lambda x, pos: labels[norm(x)])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MRsijBkf47DS"
},
"source": [
"Let's plot the map again!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 591
},
"executionInfo": {
"elapsed": 1663,
"status": "ok",
"timestamp": 1675087684895,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "odFEVMUc47DS",
"outputId": "31905199-3798-4cf3-b4c6-effb7dacff10"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(14,10))\n",
"\n",
"ax = landuse_valued[\"landuse_value\"].plot(levels=len(unique_classes), cmap=cm, norm=norm)\n",
"\n",
"# remove the ax labels\n",
"diff = norm_bins[1:] - norm_bins[:-1]\n",
"tickz = norm_bins[:-1] + diff / 2\n",
"cb = fig.colorbar(ax, format=fmt, ticks=tickz)\n",
"\n",
"# set title again\n",
"fig.axes[0].set_title('')\n",
"\n",
"fig.axes[0].set_xticks([])\n",
"fig.axes[0].set_yticks([])\n",
"fig.axes[0].set_axis_off()\n",
"\n",
"# for some weird reason we get two colorbars, so we remove one:\n",
"fig.delaxes(fig.axes[1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "u9yzw5hE47DS"
},
"source": [
"## 4. Extracting buildings from OpenStreetMap\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WMOSa6JF47DS"
},
"source": [
"There is a lot more data to extract from OpenStreetMap besides land-use information. Let's extract some building data. To do so, we use the *\"building\"* tag."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 119709,
"status": "ok",
"timestamp": 1675087861528,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "B6EiF_dN47DS"
},
"outputs": [],
"source": [
"tags = {\"building\": True}\n",
"buildings = ox.features_from_place(place_name, tags)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In case the above does not work, you can continue the assignment by using the code below (make sure you remove the hashtags to run it). If you decide to use the data as specified below, also change the map at the start to 'Kampen'."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [],
"source": [
"# remote_url = 'https://github.com/ElcoK/BigData_AED/raw/main/week5/kampen_buildings.gpkg'\n",
"# file = 'kampen_buildings.gpkg'\n",
"# \n",
"# #request.urlretrieve(remote_url, file)\n",
"# buildings = gpd.GeoDataFrame.from_file('kampen_buildings.gpkg')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bon7osXA47DT"
},
"source": [
"Now let's see what information is actually extracted:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 765
},
"executionInfo": {
"elapsed": 37,
"status": "ok",
"timestamp": 1675087861529,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "6HdghuMv47DT",
"outputId": "dbec25d2-8c62-4420-f125-b1a4ac80c318"
},
"outputs": [],
"source": [
"buildings.head()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "p8dhZx1n47DT"
},
"source": [
"As you notice in the output of the cell above, there are many columns which just contain \"NaN\". And there even seem to be to many columns to even visualize properly in one view.\n",
"\n",
"Let's check what information is collected for the different buildings:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 35,
"status": "ok",
"timestamp": 1675087861529,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "W3ZpsIkO47DT",
"outputId": "385616f8-25fe-4675-f5f0-16d7fa9b0df7"
},
"outputs": [],
"source": [
"buildings.columns"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "sH7NTKENA4WO"
},
"source": [
"\n",
"Question 6: Let's have a look at the extracted building information. Please describe in your own words the information it contains. Is there specific information that suprises you to see, and do you think anything is missing that you expected? \n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8OHDhc-047DT"
},
"source": [
"## 5. Analyze and visualize building stock\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Z37JRRc747DT"
},
"source": [
"One interesting column is called `start_date`. This shows the building year per building. \n",
"\n",
"Let's explore this year of building a bit more.\n",
"\n",
"First, it would be interesting to get an idea how many buildings are build in each year through using the `value_counts()` function. Normally, that functions ranks the values in descending order (high to low). We are more interested in how this has developed over time. So we use the `sort_index()` function to sort the values by year. Add these two functions in the cell below."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 924,
"status": "ok",
"timestamp": 1675087884735,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "lNSe826i47DT"
},
"outputs": [],
"source": [
"building_year = buildings.start_date. XXXX"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "X6b_T5xs47DU"
},
"source": [
"There is not better way to further explore this years than through plotting it. Don't forget to add things such as a x label, y label and title. Have a look at some of the matplotlib [tutorials](https://matplotlib.org/stable/tutorials/introductory/quick_start.html). Note that you need to look at the code that also uses subplots and where they use the `ax` option."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"executionInfo": {
"elapsed": 1636,
"status": "ok",
"timestamp": 1675087889714,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "fmk6m78I47DU",
"outputId": "78f3ea6a-284d-495f-b596-12db32305128"
},
"outputs": [],
"source": [
"fig,ax = plt.subplots(1,1,figsize=(5,18))\n",
"\n",
"building_year.plot(kind='barh',ax=ax)\n",
"\n",
"ax.tick_params(axis='y', which='major', labelsize=7)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AwRyhvNeBn0G"
},
"source": [
"\n",
"Question 7: Please upload a figure that shows the development of building stock over the years in your region of interest. Make sure it contains all the necessary elements (labels on the axis, title, etc.)\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wrcM1p-m47DU"
},
"source": [
"What we also noticed is that quite some buildings are identified as 'yes'. This is not very useful as it does not really say much about the use of the building. \n",
"\n",
"Let's see for how many buildings this is the case: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 205,
"status": "ok",
"timestamp": 1675087945407,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "_4eKR2Bo47DU",
"outputId": "54e29c44-9717-4eee-984f-9555659317be"
},
"outputs": [],
"source": [
"buildings.building.value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you have seen from the `value_counts` function, there are quite a few buildings with only very few tags. You could either consider to not include them in your plot at all (for example by using the `isin` function or the `query` function, see also [here](https://stackoverflow.com/questions/12096252/use-a-list-of-values-to-select-rows-from-a-pandas-dataframe)), or rename them, similar to how you named the natural land cover classes for the land-use map. "
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "vF6WJ9_k47DU"
},
"source": [
"Now let's visualize the buildings again. We need to create a similar color dictionary as we did for the land-use categories. Now its up to you to make it!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 226,
"status": "ok",
"timestamp": 1675087956546,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "RYRxKXxd47DU"
},
"outputs": [],
"source": [
"color_dict = { 'yes' : \"#f1134b\", \n",
" 'house':'#f13013', \n",
" 'industrial':'#0f045c',\n",
" 'farm':'#fcfcb9', \n",
" 'bungalow':'#f13013',\n",
" 'service':'#CB8DDB' }"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 232,
"status": "ok",
"timestamp": 1675087958726,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "YjRwC-K-47DU"
},
"outputs": [],
"source": [
"# Remove multiple keys from dictionary\n",
"color_dict = {key: color_dict[key]\n",
" for key in color_dict if key not in list(set(color_dict)-set(buildings.building.unique()))}\n",
"\n",
"map_dict = dict(zip(color_dict.keys(),[x for x in range(len(color_dict))]))\n",
"buildings['col_landuse'] =buildings.building.apply(lambda x: color_dict[x])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wGh7rbnB47DU"
},
"source": [
"And plot the figure in the same manner!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 616
},
"executionInfo": {
"elapsed": 3651,
"status": "ok",
"timestamp": 1675087966347,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "oDfamvIV47DV",
"outputId": "dbcee552-e955-4d2b-ddda-909ab4265105"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(12,10))\n",
"\n",
"# add color scheme\n",
"color_scheme_map = list(color_dict.values())\n",
"cmap = LinearSegmentedColormap.from_list(name='landuse',\n",
" colors=color_scheme_map) \n",
"\n",
"# and plot the land-use map.\n",
"buildings.plot(color=buildings['col_landuse'],ax=ax,linewidth=0)\n",
"\n",
"# remove the ax labels\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()\n",
"\n",
"# add a legend:\n",
"legend_elements = []\n",
"for iter_,item in enumerate(color_dict):\n",
" legend_elements.append(Patch(facecolor=color_scheme_map[iter_],label=item)) \n",
"\n",
"ax.legend(handles=legend_elements,edgecolor='black',facecolor='#fefdfd',prop={'size':12},loc=(1.02,0.2)) \n",
"\n",
"# add a title\n",
"ax.set_title(place_name,fontweight='bold')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IJalDDJvB6Yd"
},
"source": [
"\n",
"Question 8: Please upload a figure of your building stock map of your region of interest. Make sure that the interpretation is clear. If necessary, merge multiple categories into one (i.e., when some categories only contain 1 or 2 buildings).\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3NeIaiLO47DV"
},
"source": [
"## 6. Extracting roads from OpenStreetMap\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HpWnKfIk47DV"
},
"source": [
"Let's continue (and end) this tutorial with the core data in OpenStreetMap (it is even in the name): roads!\n",
"\n",
"Now, instead of using tags, we want to identify what type of roads we would like to extract. Let's first only extract roads that can be used to drive.\n",
"\n",
"The `graph_from_place()` function returns a `NetworkX` Graph element. You can read more about these graph elements in the introduction page of [NetworkX](https://networkx.org/documentation/stable/reference/introduction.html)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 13403,
"status": "ok",
"timestamp": 1675088179196,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "MpjxUadp47DV"
},
"outputs": [],
"source": [
"G = ox.graph_from_place(place_name, network_type=\"drive\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "NA_HAmHx47DV"
},
"source": [
"Unfortunately, it is bit difficult to easily view all the roads within such a Graph element. To be able to explore the data, we are going to convert it to a `Geopandas GeoDataFrame`, using the `to_pandas_edgelist()` function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"executionInfo": {
"elapsed": 15,
"status": "ok",
"timestamp": 1675088179197,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "4dMXZb_v47DV",
"outputId": "e615d5f8-6b96-4a32-f114-ce38b1481b70"
},
"outputs": [],
"source": [
"roads = gpd.GeoDataFrame(nx.to_pandas_edgelist(G))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yds5NBlF47DV"
},
"source": [
"In some cases, roads are classified with more than one category. If that is the case, they are captured within a `list`. To overcome this issue, we specify that we want the entire `highway` column as a `string` dtype."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 294,
"status": "ok",
"timestamp": 1675088191403,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "NxTg1jb847DV"
},
"outputs": [],
"source": [
"roads.highway = roads.highway.astype('str')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rbzl5JPR47DW"
},
"source": [
"Now we can create a plot to see how the road network is configured."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 575
},
"executionInfo": {
"elapsed": 888,
"status": "ok",
"timestamp": 1675088196301,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "uyo3Ggpc47DW",
"outputId": "e58c915a-b085-498c-e7ea-8d62f237d417"
},
"outputs": [],
"source": [
"fig, ax = plt.subplots(1, 1,figsize=(12,10))\n",
"\n",
"\n",
"roads.plot(column='highway',legend=True,ax=ax,legend_kwds={'loc': 'lower right'});\n",
"\n",
"\n",
"# remove the ax labels\n",
"ax.set_xticks([])\n",
"ax.set_yticks([])\n",
"ax.set_axis_off()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "M18fuTWM47DW",
"tags": []
},
"source": [
"It would also be interesting to explore the network a little but more interactively. **OSMnx** has a function called `plot_graph_folium()`, which allow us to use the [folium](https://python-visualization.github.io/folium/quickstart.html#Getting-Started) package to plot data interactively on a map. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 866
},
"executionInfo": {
"elapsed": 1720,
"status": "ok",
"timestamp": 1675088204394,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "lpWHR0Ez47DW",
"outputId": "38be3bea-b399-4e8f-a081-210baa559ef7"
},
"outputs": [],
"source": [
"m1 = ox.plot_graph_folium(G, popup_attribute=\"highway\", weight=2, color=\"#8b0000\")\n",
"m1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "M6-fqL9L47DW",
"tags": []
},
"source": [
"## 7. Plot Routes Using OpenStreetMap and Folium\n",
"
"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "gm8NIAR947DW"
},
"source": [
"One of the exiting things we can do with this data is that we can compute and plot routes between two points on a map.\n",
"\n",
"Let's first select two random start and end points from the graph and compute the shortest route between them through using the `shortest_path()` function of the `NetworkX` package.\n",
"\n",
"The function `ox.nearest_nodes()` looks for the nearest point in your network based on a `X` and `Y` coordinate. For example, in the code below, the origin node is based on the northwestern corner of your bounding box, whereas the destination node is based on the coordinates of the southeastern corner of your bounding box. \n",
"\n",
"So this can also be rewritten as:\n",
"\n",
"```\n",
"origin_node = ox.nearest_nodes(G,4.65465, 56.6778) \n",
"destination_node = ox.nearest_nodes(G,4.61055, 59.5487) \n",
"route = nx.shortest_path(G, origin_node, destination_node) \n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Zi_xhqXTCi3h"
},
"source": [
"\n",
"Question 9: The last element of this tutorial is to play around with routing. Please explain in your own words what the .shortest_path() algorithm does. Include the term 'Dijkstra algorithm' in your answer.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"executionInfo": {
"elapsed": 837,
"status": "ok",
"timestamp": 1675088236066,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "Dr7Ftbbh47DW"
},
"outputs": [],
"source": [
"origin_node = ox.nearest_nodes(G,area['bbox_west'].values[0], area['bbox_north'].values[0])\n",
"destination_node = ox.nearest_nodes(G,area['bbox_east'].values[0], area['bbox_south'].values[0])\n",
"route = nx.shortest_path(G, origin_node, destination_node)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4UuCS8G247DW"
},
"source": [
"We can plot the route with folium. Like above, you can pass keyword args along to folium PolyLine to style the lines."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 866
},
"executionInfo": {
"elapsed": 240,
"status": "ok",
"timestamp": 1675088397348,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "7QrZ6Gpi47DX",
"outputId": "33fecead-a6d7-4090-99da-e09d0c34081a"
},
"outputs": [],
"source": [
"m2 = ox.plot_route_folium(G, route, weight=10)\n",
"m2"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eedHqPli47DX"
},
"source": [
"Plot the route with folium on top of the previously created map\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 866
},
"executionInfo": {
"elapsed": 2518,
"status": "ok",
"timestamp": 1675088413924,
"user": {
"displayName": "RA Odongo",
"userId": "17326618845752559881"
},
"user_tz": -60
},
"id": "aHzxZAbZ47DX",
"outputId": "01ee7d97-4792-41fb-925c-c44fb9b15a3f"
},
"outputs": [],
"source": [
"m3 = ox.plot_route_folium(G, route, route_map=m1, popup_attribute=\"name\", weight=7)\n",
"m3"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Question 10: Please add one more routes on a map and upload the resulting figure here.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"colab": {
"provenance": [
{
"file_id": "https://github.com/ElcoK/BigData_AED/blob/main/week4/tutorial1.ipynb",
"timestamp": 1675085725524
}
]
},
"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.11"
},
"vscode": {
"interpreter": {
"hash": "f323064ae63d54ed8d769390a968e914fbf7abacffc63e116cd2e04a08ed2d24"
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}