Python_Geospatial_Bootcamp_2023_Libraries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Python Geospatial Libraries\n",
        "\n",
        "An introduction to some of the core python libraries that provide geospatial capabilities. The following libraries are not a full list of geospatial python libraries, not even close, but a selection to provide users with an idea of what can be acomplished with python.  "
      ],
      "metadata": {
        "id": "x2_x95QBrTsD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# click the play button to the left to run this code\n",
        "print(\"Lets get started!\")"
      ],
      "metadata": {
        "id": "7MJGS3DJHveH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Shapely\n",
        "___\n",
        "\n",
        "Shapely is a Python library for manipulation and analysis of planar geometric objects, which are based on the widely adopted GEOS library (the engine of PostGIS).\n",
        "\n",
        "Shapely is particularly good for tasks that involve geometries like points, lines, and polygons. It supports operations like buffer, union, intersection, and difference, among others.\n",
        "\n",
        "```\n",
        "> pip install shapely\n",
        "```"
      ],
      "metadata": {
        "id": "ccPvRqedsjra"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Basic Geometric Operations"
      ],
      "metadata": {
        "id": "FzFRVAIHwKdQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from shapely.geometry import Point, LineString, Polygon\n",
        "\n",
        "# Create a point\n",
        "point = Point(0, 0)\n",
        "# the positions are (x, y)\n",
        "\n",
        "# Create a line\n",
        "line = LineString([(0, 0), (1, 1), (2, 0)])\n",
        "\n",
        "# Create a polygon\n",
        "polygon = Polygon([(0, 0), (1, 1), (1, 0)])"
      ],
      "metadata": {
        "id": "3t7w0tNwwTnL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets now look at the objects created, switch the \"point\" below with the polygon variable."
      ],
      "metadata": {
        "id": "dttK1WbLxceK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "line"
      ],
      "metadata": {
        "id": "ESexIPb2xZOl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Buffer\n",
        "\n",
        "With these objects we can use the pre-build functions to perform different operations."
      ],
      "metadata": {
        "id": "lgJF-XUqx7X5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a buffer around the point\n",
        "buffer = point.buffer(1.0)\n",
        "\n",
        "print(buffer.area)"
      ],
      "metadata": {
        "id": "Oe5ffly2yDRA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "buffer"
      ],
      "metadata": {
        "id": "pytdAwk-yTaP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Object Attributes + Methods\n",
        "\n",
        "Shapely object have a number of built in methods (functions) and attributes that can be easily accessed. Examples are \"length\", \"area\", \"bounds\", \"centroid\"."
      ],
      "metadata": {
        "id": "d5gGdnp1zftG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "> **TO DO:** in the same way we found the area of the buffer above, find the boundary of the buffer.\n"
      ],
      "metadata": {
        "id": "63kGkwgLya8Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"buffer boundary: \\n\")\n",
        "\n",
        "# type below to access the boundary"
      ],
      "metadata": {
        "id": "PFpMS45eyZrL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Union"
      ],
      "metadata": {
        "id": "KcTlr2_Uy6mQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create another point\n",
        "point2 = Point(2, 2)\n",
        "\n",
        "# Create union of the two points (result will be a MultiPoint geometry)\n",
        "union_result = point.union(point2)"
      ],
      "metadata": {
        "id": "vZw47BgKzEuE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "union_result"
      ],
      "metadata": {
        "id": "G4NucNPMzOq9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Intersection"
      ],
      "metadata": {
        "id": "Y-2gi7FozIk1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create another line\n",
        "line2 = LineString([(0, 0), (0, 2)])\n",
        "\n",
        "# Find intersection (result will be a Point or LineString depending on the overlap)\n",
        "intersection_result = line.intersection(line2)"
      ],
      "metadata": {
        "id": "SSPt6AEIzGYV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "line # 0,0 1,1 2,0"
      ],
      "metadata": {
        "id": "KBFfLA7P2mPp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "line2 # 0,0 0,2"
      ],
      "metadata": {
        "id": "HXDEkeRZ2rPg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# can access the xy of the point where these two lines cross\n",
        "print(intersection_result.coords.xy)"
      ],
      "metadata": {
        "id": "Rz7hIt3azTNt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Relationships Between Objects\n",
        "\n",
        "Shapely can also test for different types of spatial relationships between geometries."
      ],
      "metadata": {
        "id": "WjoZ8bYP17ci"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check if a point is within a polygon\n",
        "print(point.within(polygon))\n",
        "\n",
        "# Check if a polygon contains a point\n",
        "print(polygon.contains(point))"
      ],
      "metadata": {
        "id": "irQTHc8Y2B6k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is just a brief introduction, and Shapely has many more capabilities to explore, such as geometry validation, simplification, and precise configuration of operations. It's a powerful library for anyone working with geospatial data in Python."
      ],
      "metadata": {
        "id": "rC0xfcoj2CZ4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fiona & PyProj\n",
        "___\n",
        "**Fiona** is a library for reading and writing vector data (i.e., data that is made up of points, lines, and polygons).\n",
        "\n",
        "It provides a straightforward and Pythonic interface to work with geospatial data built on top of the powerful GDAL.\n",
        "\n",
        "Can handle multiple formats like Shapefiles, GeoJSON, and others.\n",
        "\n",
        "```\n",
        "> pip install fiona\n",
        "```\n",
        "\n",
        "**PyProj** is a Python interface to the proj library, which is used for cartographic projections and coordinate transformations.\n",
        "\n",
        "PyProj is often used in combination with other geospatial libraries like Fiona and Shapely.\n",
        "\n",
        "```\n",
        "> pip install pyproj\n",
        "```"
      ],
      "metadata": {
        "id": "2E0ekpsM7fGg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Reading Data\n",
        "\n",
        "The feature object is a Python dictionary complying with the GeoJSON format.\n",
        "\n",
        "We don't have a directory to read from but just so you can see how little code this is I wanted to add it."
      ],
      "metadata": {
        "id": "ywXCaaMH_Ftq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import fiona\n",
        "\n",
        "# Opening  the shapefile would look like this\n",
        "\"\"\"\n",
        "with fiona.open(\"path/to/file/coutwildrnp.shp\", \"r\") as src:\n",
        "    # Loop through the features and print them\n",
        "    for feature in src:\n",
        "        print(feature)\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "oH5qDA8Q-713"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Writing Data\n",
        "\n"
      ],
      "metadata": {
        "id": "uWTMc9swB1fp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Schema of the new shapefile\n",
        "schema = {\n",
        "    'geometry': 'Point',\n",
        "    'properties': {'id': 'int', 'name': 'str'}\n",
        "}\n",
        "\n",
        "# Data for the new shapefile\n",
        "features = [\n",
        "    {\n",
        "        'geometry': {'type': 'Point', 'coordinates': (0, 0)},\n",
        "        'properties': {'id': 1, 'name': 'First Point'}\n",
        "    },\n",
        "    {\n",
        "        'geometry': {'type': 'Point', 'coordinates': (1, 1)},\n",
        "        'properties': {'id': 2, 'name': 'Second Point'}\n",
        "    }\n",
        "]\n",
        "\n",
        "# Write the shapefile would look like the code below\n",
        "\"\"\"\n",
        "with fiona.open('file/path/output.shp', 'w', driver='ESRI Shapefile', schema=schema) as dst:\n",
        "    for feature in features:\n",
        "        dst.write(feature)\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "oQZwN7slB0gA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Basic Coordinate Transformations - PyProj\n",
        "\n",
        "PyProj allows you to convert coordinates from one CRS (Coordinate Reference System) to another. Here's an example to convert coordinates from WGS84 (EPSG:4326) to Web Mercator (EPSG:3857):"
      ],
      "metadata": {
        "id": "6a1lzeTSEWTh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyproj import Transformer\n",
        "\n",
        "# Create a transformer object\n",
        "transformer = Transformer.from_crs(\"EPSG:4326\", \"EPSG:26917\")\n",
        "\n",
        "# Perform the transformation\n",
        "x, y = transformer.transform(50, -80)  # Note that the order is (lat, lon)\n",
        "\n",
        "# Note that this output is radians\n",
        "print(f\"Transformed coordinates: x={x}, y={y}\")"
      ],
      "metadata": {
        "id": "aJkUkv_GEVSH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Geodetic Calculations\n",
        "\n",
        "PyProj can also be used to perform various geodetic calculations like distance, forward, and inverse geodetic problems."
      ],
      "metadata": {
        "id": "nzupUD14Fq9o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyproj import Geod\n",
        "\n",
        "# Create a Geod object\n",
        "geod = Geod(ellps=\"WGS84\")\n",
        "\n",
        "# Calculate distance and angles between two points\n",
        "lat1, lon1 = 37.75, -122.45  # San Francisco\n",
        "lat2, lon2 = 34.05, -118.25  # Los Angeles\n",
        "\n",
        "az12, az21, distance = geod.inv(lon1, lat1, lon2, lat2)"
      ],
      "metadata": {
        "id": "r5Cn30swFrci"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Printing the calcualted metrics:"
      ],
      "metadata": {
        "id": "ZaP9bRE7GG3O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Distance: {distance} meters\")\n",
        "print(f\"Forward azimuth: {az12} degrees\")\n",
        "print(f\"Backward azimuth: {az21} degrees\")"
      ],
      "metadata": {
        "id": "7M9da0KvFujs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## GeoPandas\n",
        "____\n",
        "\n",
        "Makes working with geospatial data in python easier by extending datatypes used by pandas to allow spatial operations on geometric types. GeoPandas enables you to easily do operations in python, such as joins or cuts, that would otherwise require a spatial database such as PostGIS.\n",
        "\n",
        "- Geometric operations are performed by shapely.\n",
        "- Geopandas further depends on fiona for file access and matplotlib for plotting.\n",
        "\n",
        "```\n",
        "> pip install geopandas\n",
        "```"
      ],
      "metadata": {
        "id": "1jUJqrPkr3VX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Reading Spatial Data from a File\n",
        "\n",
        "GeoPandas can read various types of spatial data files, such as shapefiles, GeoJSON, and more. Reading a shapefile is as simple as the code below."
      ],
      "metadata": {
        "id": "SaK-SJSHrR0M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import geopandas as gpd\n",
        "import requests\n",
        "from io import StringIO\n",
        "\n",
        "# URL for a GeoJSON file\n",
        "url = \"https://raw.githubusercontent.com/johan/world.geo.json/master/countries.geo.json\"\n",
        "\n",
        "# Fetch the content\n",
        "response = requests.get(url)\n",
        "data = response.text\n",
        "\n",
        "# Read the GeoJSON content into a GeoDataFrame\n",
        "gdf = gpd.read_file(StringIO(data), driver=\"GeoJSON\")\n",
        "\n",
        "# Print the first 5 rows\n",
        "print(gdf.head())"
      ],
      "metadata": {
        "id": "fQb1pHMUNI-E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Basic Operations\n",
        "\n",
        "**Filtering by Geometry** is how you could filter all polygons that overlap with your target polygon, this can also be done with points within a certain boundary."
      ],
      "metadata": {
        "id": "CqOVAgV9IEXW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First step is to create a new polygon."
      ],
      "metadata": {
        "id": "Wtr48dJXUTV3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from shapely.geometry import shape\n",
        "import json\n",
        "\n",
        "# Sample GeoJSON string for a polygon\n",
        "geojson_str = \"\"\"\n",
        "{\n",
        "    \"type\": \"Polygon\",\n",
        "    \"coordinates\": [\n",
        "        [\n",
        "            [-79.45015642620336,43.64738992644382],\n",
        "            [-79.3698344704733,43.64738992644382],\n",
        "            [-79.3698344704733,43.683807516070885],\n",
        "            [-79.45015642620336,43.683807516070885],\n",
        "            [-79.45015642620336,43.64738992644382]\n",
        "        ]\n",
        "    ]\n",
        "}\n",
        "\"\"\"\n",
        "\n",
        "# Load the GeoJSON string and parse it into a geometry\n",
        "geometry = shape(json.loads(geojson_str))\n",
        "\n",
        "# Now you can create a GeoDataFrame\n",
        "polygon_gdf = gpd.GeoDataFrame({'geometry': [geometry]})\n",
        "\n",
        "print(polygon_gdf)"
      ],
      "metadata": {
        "id": "d5BZLzk-Tslf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next we can find the overlapping polygons."
      ],
      "metadata": {
        "id": "LAMx_DyfVaha"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Use spatial join to find polygons in gdf that overlap with single_polygon_gdf\n",
        "overlapping = gpd.sjoin(gdf, polygon_gdf, how=\"inner\", op=\"intersects\")\n",
        "\n",
        "# I left the error below in to show how smart geopandas is\n",
        "\n",
        "overlapping.head()"
      ],
      "metadata": {
        "id": "4My8_M86IOp5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Visualization\n",
        "\n",
        "GeoPandas also makes it simple to plot your data. To do this we're also going to take advantage of the **matplotlib** python library."
      ],
      "metadata": {
        "id": "HGI1uOk9I4Av"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot all country polygons\n",
        "gdf.plot(color='red')\n",
        "plt.show()\n",
        "\n",
        "# Plot our custom polygon\n",
        "polygon_gdf.plot(color='blue')\n",
        "plt.show()\n",
        "\n",
        "# Plot the country polygon overlapping with our custom polygon\n",
        "overlapping.plot(color='green')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "KGZDnk5ZI25h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Folium\n",
        "\n",
        "Used to visualize data on an interactive leaflet map.\n",
        "Enables both the binding of data to a map for choropleth visualizations as well as passing rich vector/raster/HTML visualizations as markers on the map.\n",
        "\n",
        "```\n",
        "> pip install folium\n",
        "```"
      ],
      "metadata": {
        "id": "fk4xu-ZRXZ6P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating a Basic Interactive Map"
      ],
      "metadata": {
        "id": "_ES3pQraZN4P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import folium\n",
        "\n",
        "# Create a base map\n",
        "fol_map_1 = folium.Map(location=[43.72, -79.38], tiles='OpenStreetMap', zoom_start=10)\n",
        "\n",
        "# Display the map\n",
        "fol_map_1"
      ],
      "metadata": {
        "id": "49azKJRsZAnR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Switch the \"tiles\" option to one of the following:\n",
        "\n",
        "- stamenterrain\n",
        "- cartodbpositron\n",
        "- cartodbdark_matter\n",
        "- stamenwatercolor\n",
        "- stamentoner"
      ],
      "metadata": {
        "id": "r7RC0SmObGGA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Adding context to polygons with base maps\n",
        "\n",
        "Lets use the existing polygon in geopandas to get a better idea of where it is."
      ],
      "metadata": {
        "id": "8JGoDHN-YvxM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Add GeoDataFrame to the map\n",
        "folium.GeoJson(geometry).add_to(fol_map_1)\n",
        "\n",
        "fol_map_1"
      ],
      "metadata": {
        "id": "poYcOzLZZTzx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Mapping some data\n",
        "\n",
        "First lets make a new set of polygons that have an additional value"
      ],
      "metadata": {
        "id": "4uL_KkQUZizX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define polygons for each region\n",
        "vancouver_poly = Polygon([[-123.3, 48.8], [-122.2, 48.8], [-122.2, 49.7], [-123.3, 49.7]])\n",
        "calgary_poly = Polygon([[-114.4, 50.7], [-113.5, 50.7], [-113.5, 51.3], [-114.4, 51.3]])\n",
        "toronto_poly = Polygon([[-80.0, 43.3], [-78.5, 43.3], [-78.5, 44.1], [-80.0, 44.1]])\n",
        "\n",
        "# Create a GeoDataFrame\n",
        "data = {\n",
        "    'region': ['Vancouver', 'Calgary', 'Toronto'],\n",
        "    'Coolness': [250, 50, 500],\n",
        "    'geometry': [vancouver_poly, calgary_poly, toronto_poly]\n",
        "}\n",
        "\n",
        "gdf = gpd.GeoDataFrame(data)\n",
        "\n",
        "# Convert GeoDataFrame to GeoJSON\n",
        "geojson = gdf.to_json()\n",
        "\n",
        "print(geojson)"
      ],
      "metadata": {
        "id": "4N3HGpzQeMDz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now lets create a new map and add our data to it."
      ],
      "metadata": {
        "id": "Nj3hZFkNeo2L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the base map\n",
        "fol_map_2 = folium.Map(location=[55, -106], tiles=\"cartodbdark_matter\", zoom_start=4)\n",
        "\n",
        "# Add the Choropleth layer to the map\n",
        "folium.Choropleth(\n",
        "    geo_data=gdf.to_json(),\n",
        "    data=gdf,\n",
        "    columns=['region', 'Coolness'],\n",
        "    key_on='feature.properties.region',\n",
        "    fill_color='YlGn',\n",
        "    fill_opacity=0.5,\n",
        "    line_opacity=0,\n",
        "    legend_name='Coolness in Regions'\n",
        ").add_to(fol_map_2)\n",
        "\n",
        "fol_map_2"
      ],
      "metadata": {
        "id": "h2w4N1lLZiOT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Basic Analysis with Leafmap"
      ],
      "metadata": {
        "id": "eZNnvXWKtnXQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install leafmap"
      ],
      "metadata": {
        "id": "Om2cCKEZt6Ab"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also create maps that have dynamic elements, like the polygon fill colour."
      ],
      "metadata": {
        "id": "MgtIZwX4wZTN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import leafmap\n",
        "\n",
        "m_2 = leafmap.Map(center=[0, 0], zoom=2)\n",
        "\n",
        "url = \"https://raw.githubusercontent.com/opengeos/leafmap/master/examples/data/countries.geojson\"\n",
        "\n",
        "# a function to select random colors\n",
        "def random_color(feature):\n",
        "    return {\n",
        "        'color': 'black',\n",
        "        'fillColor': random.choice(['red', 'yellow', 'green', 'orange', \"blue\"]),\n",
        "    }\n",
        "\n",
        "\n",
        "m_2.add_geojson(url, layer_name=\"Countries\", style_callback=random_color)\n",
        "\n",
        "# display the map\n",
        "m_2"
      ],
      "metadata": {
        "id": "KghbX3WJvdti"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can create an interactive map of niagara beaches! There is also built in support for whitebox tools.\n",
        "\n",
        "The information is drawn directly from a file hosted on an open data portal:\n",
        "https://niagaraopendata.ca/dataset/beaches"
      ],
      "metadata": {
        "id": "58dswZ47t-aD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# collect the data from the web - its a geojson\n",
        "geojson_url = \"https://niagaraopendata.ca/dataset/1ca52a3b-03a9-412f-a10a-59ddab0743c5/resource/15db2b16-abe9-469f-9441-80fc3e355b8d/download/beaches.json\"\n",
        "\n",
        "# create the map\n",
        "m = leafmap.Map(center=[43.052, -79.441], zoom=9)\n",
        "\n",
        "# add the point layer\n",
        "m.add_point_layer(geojson_url, popup=[\"BEACH_NAME\", \"BEACH_TYPE\", \"BEACH_PARKING\", \"BEACH_WASHROOM\"], layer_name=\"Beaches\")\n",
        "\n",
        "# display the map\n",
        "m"
      ],
      "metadata": {
        "id": "sTOCTCJkuC8d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## PySAL Examples\n",
        "---\n",
        "\n",
        "PySAL provides a very helpful examples package that makes exploring the different libraries very easy."
      ],
      "metadata": {
        "id": "PIMEY0c-84Xk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install libpysal"
      ],
      "metadata": {
        "id": "r6O3NJwg9GTn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import libpysal.examples"
      ],
      "metadata": {
        "id": "cN1jof9O859k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are several open data sources available to us that we can use in analysis. We can review them in a dataframe."
      ],
      "metadata": {
        "id": "PMS66HWPHuG4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "libpysal.examples.summary()"
      ],
      "metadata": {
        "id": "LucBXCo19xmK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df = libpysal.examples.available()\n",
        "\n",
        "df.head(15)"
      ],
      "metadata": {
        "id": "F2CHFxls-EsF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can look at the details of one dataset were interested in."
      ],
      "metadata": {
        "id": "AEHtkNLxHXV6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "libpysal.examples.explain(\"AirBnB\")"
      ],
      "metadata": {
        "id": "h6gdXxBBGtTX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Its very easy to download the data or access the direct link to its source."
      ],
      "metadata": {
        "id": "CoWevBs2HQ4r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "airbnb = libpysal.examples.load_example(\"AirBnB\")"
      ],
      "metadata": {
        "id": "53TIn7Q-9jZo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "airbnb_url = libpysal.examples.get_url('AirBnB')\n",
        "\n",
        "airbnb_url"
      ],
      "metadata": {
        "id": "tCD9-_MQE8Q5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "View all the files available to us within the zip folder."
      ],
      "metadata": {
        "id": "jGarhLG7HKnz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "airbnb.get_file_list()"
      ],
      "metadata": {
        "id": "kq41heIQHEck"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's load one of the files and put it on a chart."
      ],
      "metadata": {
        "id": "HwplT2gCIJsS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "airbnb_df = gpd.read_file(airbnb.get_path('airbnb_Chicago 2015.shp'))\n",
        "\n",
        "%matplotlib inline\n",
        "airbnb_df.plot()"
      ],
      "metadata": {
        "id": "MSllfWTsIIZA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's explore the dataframe to make sure we have all the information were interested in."
      ],
      "metadata": {
        "id": "iECtjA-qJ-G_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "airbnb_df.head()"
      ],
      "metadata": {
        "id": "dgjuUBJBJ3es"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Is there a relationship between the income Price Per Person of an AirBnB and the Hardship Index?\n"
      ],
      "metadata": {
        "id": "0S-OF1B8Qam3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# setup the chart with two subplots\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 7))\n",
        "\n",
        "# plot the price per person\n",
        "airbnb_df.plot(column='price_pp', cmap='viridis', legend=True, ax=ax1)\n",
        "ax1.set_title('Price Per Person')\n",
        "\n",
        "# plot the poverty\n",
        "airbnb_df.plot(column='harship_in', cmap='inferno', legend=True, ax=ax2)\n",
        "ax2.set_title('Hardship Index')"
      ],
      "metadata": {
        "id": "6IfE19a_Lxvk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "\n",
        "# OSMnx: Python for Street Networks\n",
        "---\n",
        "\n",
        "OSMnx is a Python package to retrieve, model, analyze, and visualize street networks from OpenStreetMap.\n",
        "\n",
        "Users can download and model walkable, drivable, or bikeable urban networks with a single line of Python code, and then easily analyze and visualize them.\n",
        "\n",
        "```\n",
        "> pip install osmnx\n",
        "```"
      ],
      "metadata": {
        "id": "WRlfcgVoMr6x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This time we actually do need to install it, since its not pre-installed in Colab."
      ],
      "metadata": {
        "id": "Cj84hWJ7NOTW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# pip install the OSMnx package\n",
        "!pip install osmnx"
      ],
      "metadata": {
        "id": "0_iLqKWjNGHx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Get administrative place boundaries and shapefiles\n",
        "\n",
        "To start we can read areas directly from open street maps."
      ],
      "metadata": {
        "id": "_s-bfLkINT25"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import osmnx as ox\n",
        "\n",
        "# select the places we want\n",
        "places = ox.geocode_to_gdf(['Ontario, Canada', 'Quebec, Canada', 'Manitoba, Canada'])\n",
        "places = ox.project_gdf(places)\n",
        "\n",
        "# plot the areas\n",
        "ax = places.plot()\n",
        "_ = ax.axis('off')"
      ],
      "metadata": {
        "id": "Lykr3K0nM9V2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "city = ox.geocode_to_gdf('Toronto, Ontario, Canada')\n",
        "ax = ox.project_gdf(city).plot()\n",
        "_ = ax.axis('off')"
      ],
      "metadata": {
        "id": "rhp7Qb4UOXpP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Download and model street networks\n",
        "\n",
        "OSMnx lets you download street network data and build topologically-corrected street networks, project and plot the networks, and save the street network as SVGs, GraphML files, or shapefiles for later use.\n",
        "\n",
        "Streets can be selected in the following ways:\n",
        "\n",
        "- a bounding box\n",
        "- a lat-long point plus a distance\n",
        "- an address plus a distance\n",
        "- a polygon of the desired street network’s boundaries\n",
        "- a place name or list of place names"
      ],
      "metadata": {
        "id": "W58U0AaNOjGC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# selecting a smaller city for speed\n",
        "niagara_city = ox.graph_from_place('Niagara Falls, Ontario, Canada', network_type='drive')\n",
        "\n",
        "ox.plot_graph(niagara_city)"
      ],
      "metadata": {
        "id": "-pnEymcnQEsz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Getting building sets for cities\n",
        "\n",
        "We can retrieve all the polygons within a city to export."
      ],
      "metadata": {
        "id": "etutp-6yTfNq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Retrieve buildings in a neighborhood\n",
        "buildings = ox.features_from_place(\"St. Catharines, Ontario, Canada\", tags={\"building\": True})\n",
        "# this returns a dataframe we can plot\n",
        "\n",
        "ox.project_gdf(buildings).plot(color='blue')\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "Nt4WLdDUROdC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Analyzing the network\n",
        "\n",
        "Let's find the shortest path between two nodes"
      ],
      "metadata": {
        "id": "9OMDipXvTaGf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "\n",
        "# Get the street network for a place\n",
        "welland_graph = ox.graph_from_place('Welland, Ontario, Canada')"
      ],
      "metadata": {
        "id": "wJ8f4LRSTWUp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can select individual nodes as our start and end points."
      ],
      "metadata": {
        "id": "8azWJleRUJv_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Select two nodes and compute the shortest path\n",
        "orig_node = list(welland_graph.nodes())[5]\n",
        "dest_node = list(welland_graph.nodes())[300]\n",
        "\n",
        "# using the networkx package\n",
        "route = nx.shortest_path(welland_graph, orig_node, dest_node, weight='length')\n",
        "\n",
        "ox.plot_graph_route(welland_graph, route)"
      ],
      "metadata": {
        "id": "FXJGgkJPT4ro"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}