spatial/intro_geospatial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing Geospatial Data in Python (DataCamp)\n",
    "\n",
    "## Shapefiles\n",
    "- Store datatype known as geometry\n",
    "    - Point: single lat/lng pair\n",
    "    - Line: 2+ lat/lng pairs that can be connected\n",
    "    - Polygon: 3+ lat/lng pairs joined in a specified order to create an enclosed region\n",
    "- Shapefile components\n",
    "    - my_map.shp (contains geometry)\n",
    "    - my_map.dbf (holds attributes of each geometry)\n",
    "    - my_map.shx (links the attributes to the geometry)\n",
    "- Geopandas lets you read in shapefiles\n",
    "    - geo_df = gpd.read_file('my_map.shp')\n",
    "    - geo_df.head()\n",
    "    - Plotting: geo_df.iloc[0, 'geometry']\n",
    "    - Printing: print(geo_df.iloc[0, 'geometry'])\n",
    "    - Plotting dataframe: geo_df.plot(); plt.show()\n",
    "    - Plotting dataframe and colouring: geo_df.plot(column='district', legend=True); plt.show()\n",
    "    \n",
    "## Getting started reading files and plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import geopandas\n",
    "import geopandas as gpd \n",
    "\n",
    "# Read in the services district shapefile and look at the first few rows.\n",
    "service_district = gpd.read_file(shapefile_path)\n",
    "print(service_district.head())\n",
    "\n",
    "# Print the contents of the service districts geometry in the first row\n",
    "print(service_district.loc[0, 'geometry'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import geopandas as gpd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot the Service Districts without any additional arguments\n",
    "service_district.plot()\n",
    "plt.show()\n",
    "\n",
    "# Plot the Service Districts, color them according to name, and show a legend\n",
    "service_district.plot(column = 'name', legend = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting points over polygons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the service district shapefile\n",
    "service_district.plot(column='name')\n",
    "\n",
    "# Add the chicken locations\n",
    "plt.scatter(x=chickens.lng, y=chickens.lat, c = 'black')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the service district shapefile\n",
    "service_district.plot(column='name', legend=True)\n",
    "\n",
    "# Add the chicken locations\n",
    "plt.scatter(x=chickens.lng, y=chickens.lat, c = 'black', edgecolor = 'white')\n",
    "\n",
    "\n",
    "# Add labels and title\n",
    "plt.title('Nashville Chicken Permits')\n",
    "plt.xlabel('longitude')\n",
    "plt.ylabel('latitude')\n",
    "\n",
    "# Add grid lines and show the plot\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GeoJSON\n",
    "- Single file, unlike shapefiles\n",
    "- Also supports multipoints, multilines, and multipolygons\n",
    "\n",
    "### Colormaps\n",
    "When you want to differentiate regions, but not imply any type of relationship between the regions, a qualitative colormap is the best choice. In this exercise you'll compare a qualitative colormap to a sequential (quantitative) colormap using the school districts GeoDataFrame. It is available in your workspace as school_districts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set legend style\n",
    "lgnd_kwds = {'title': 'School Districts',\n",
    "               'loc': 'upper left', 'bbox_to_anchor': (1, 1.03), 'ncol': 1}\n",
    "\n",
    "# Plot the school districts using the summer colormap (sequential)\n",
    "school_districts.plot(column = 'district', cmap = 'summer', legend = True, legend_kwds = lgnd_kwds)\n",
    "plt.xlabel('Latitude')\n",
    "plt.ylabel('Longitude')\n",
    "plt.title('Nashville School Districts')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map Nashville neighborhoods\n",
    "This time you'll read a GeoJSON file in to a GeoDataFrame to take a quick peek at where Nashville neighborhoods are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas as gpd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Read in the neighborhoods geojson file\n",
    "neighborhoods = gpd.read_file(neighborhoods_path)\n",
    "\n",
    "# Print the first few rows of neighborhoods\n",
    "print(neighborhoods.head())\n",
    "\n",
    "# Plot the neighborhoods, color according to name and use the Dark2 colormap\n",
    "neighborhoods.plot(column = 'name', cmap = 'Dark2')\n",
    "\n",
    "# Show the plot.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coordinate Reference System (CRS)\n",
    "- Setting the CRS tells gpd how to interpret lng/lat values\n",
    "- Common CRSs\n",
    "    - EPSG:4326\n",
    "        - Used by google earth\n",
    "        - Units are decimal degrees\n",
    "    - EPSG:3857\n",
    "        - Used by Google Maps, Bing Maps, Open Street Maps\n",
    "        - Units are metres\n",
    "- Geometry is a required data structure of dataframes\n",
    "    - Can build up using the shapely package\n",
    "    \n",
    "### Changing coordinate reference systems\n",
    "In this exercise you will learn how to find a GeoDataFrame's coordinate reference system and how to change it. The school districts GeoDataFrame is available in your workspace as school_districts.\n",
    "\n",
    "You can change the coordinate reference system of a GeoDataFrame by changing the crs property of the GeoDataFrame. Notice that the units for geometry change when you change the CRS. You always need to ensure two GeoDataFrames **share the same crs before you spatially join them.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the first row of school districts GeoDataFrame and the crs\n",
    "print(school_districts.head(1))\n",
    "print(school_districts.crs)\n",
    "\n",
    "# Convert the crs to epsg:3857\n",
    "school_districts.geometry = school_districts.geometry.to_crs(epsg = 3857)\n",
    "                        \n",
    "# Print the first row of school districts GeoDataFrame and the crs again\n",
    "print(school_districts.head(1))\n",
    "print(school_districts.crs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Construct a gpd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import geopandas as gpd\n",
    "from shapely.geometry import Point\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Print the first few rows of the art DataFrame\n",
    "print(art.head())\n",
    "\n",
    "# Create a geometry column from lng & lat\n",
    "art['geometry'] = art.apply(lambda x: Point(float(x.lng), float(x.lat)), axis=1)\n",
    "\n",
    "# Create a GeoDataFrame from art and verify the type\n",
    "art_geo = gpd.GeoDataFrame(art, crs = neighborhoods.crs, geometry = art.geometry)\n",
    "print(type(art_geo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spatial joins\n",
    "- sjoin\n",
    "- op: type of spatial operation\n",
    "    - Intersects: Region intersects points\n",
    "    - Contains: Observations completely contained\n",
    "    - Within: Points within a region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Spatially join art_geo and neighborhoods \n",
    "art_intersect_neighborhoods = gpd.sjoin(art_geo, neighborhoods, op = 'intersects')\n",
    "\n",
    "# Print the shape property of art_intersect_neighborhoods\n",
    "print(art_intersect_neighborhoods.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create art_within_neighborhoods by spatially joining art_geo and neighborhoods\n",
    "art_within_neighborhoods = gpd.sjoin(art_geo, neighborhoods, op = 'within')\n",
    "\n",
    "# Print the shape property of art_within_neighborhoods\n",
    "print(art_within_neighborhoods.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Spatially join art_geo and neighborhoods and using the contains op\n",
    "art_containing_neighborhoods = gpd.sjoin(art_geo, neighborhoods, op = 'contains')\n",
    "\n",
    "# Print the shape property of art_containing_neighborhoods\n",
    "print(art_containing_neighborhoods.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import packages\n",
    "import geopandas as gpd\n",
    "import pandas as pd\n",
    "\n",
    "# Spatially join neighborhoods with art_geo\n",
    "neighborhood_art = gpd.sjoin(art_geo, neighborhoods, op = \"within\")\n",
    "\n",
    "# Print the first few rows\n",
    "print(neighborhood_art.head())\n",
    "\n",
    "# Get name and title from neighborhood_art and group by name\n",
    "neighborhood_art_grouped = neighborhood_art[['name', 'title']].groupby('name')\n",
    "\n",
    "# Aggregate the grouped data and count the artworks within each polygon\n",
    "print(neighborhood_art_grouped.agg('count').sort_values(by = 'title', ascending = False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create urban_art from neighborhood_art where the neighborhood name is Urban Residents\n",
    "urban_art = neighborhood_art.loc[neighborhood_art.name == \"Urban Residents\"]\n",
    "\n",
    "# Get just the Urban Residents neighborhood polygon and save it as urban_polygon\n",
    "urban_polygon = neighborhoods.loc[neighborhoods.name == \"Urban Residents\"]\n",
    "\n",
    "# Plot the urban_polygon as ax \n",
    "ax = urban_polygon.plot(color = 'lightgreen')\n",
    "\n",
    "# Add a plot of the urban_art and show it\n",
    "urban_art.plot( ax = ax, column = 'type', legend = True);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geopandas attributes and methods\n",
    "- Inherits useful functionality from Shapely package\n",
    "    - area: area of each geometry (if units are decimal degrees, then returns decimal degrees squared)\n",
    "    - centroid: center point\n",
    "    - distance: min distance to another location\n",
    "- You can convert CRS to one that uses metres for distance to make it easier to interpret\n",
    "    - metres_df = degrees_df.to_crs(epsg=3857)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the head of the urban polygon \n",
    "print(urban_polygon.head())\n",
    "\n",
    "# Create a copy of the urban_polygon using EPSG:3857 and print the head\n",
    "urban_poly_3857 = urban_polygon.to_crs(epsg = 3857)\n",
    "print(urban_poly_3857.head())\n",
    "\n",
    "# Print the area of urban_poly_3857 in kilometers squared\n",
    "area = urban_poly_3857.geometry.area / 10**6\n",
    "print('The area of the Urban Residents neighborhood is ', area[0], ' km squared')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create downtown_center from urban_poly_3857\n",
    "downtown_center = urban_poly_3857.geometry.centroid\n",
    "\n",
    "# Print the type of downtown_center \n",
    "print(type(downtown_center))\n",
    "\n",
    "# Plot the urban_poly_3857 as ax and add the center point\n",
    "ax = urban_poly_3857.plot(color = 'lightgreen')\n",
    "downtown_center.plot(ax = ax, color = 'black')\n",
    "plt.xticks(rotation = 45)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "from shapely.geometry import Point\n",
    "import geopandas as gpd\n",
    "import pandas as pd\n",
    "\n",
    "# Create art_dist_meters using art and the geometry from art\n",
    "art_dist_meters = gpd.GeoDataFrame(art, geometry = art.geometry, crs = {'init': 'epsg:4326'})\n",
    "print(art_dist_meters.head(2))\n",
    "\n",
    "# Set the crs of art_dist_meters to use EPSG:3857\n",
    "art_dist_meters.geometry = art_dist_meters.geometry.to_crs(epsg = 3857)\n",
    "print(art_dist_meters.head(2))\n",
    "\n",
    "# Add a column to art_meters, center\n",
    "art_dist_meters['center'] = center_point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import package for pretty printing\n",
    "import pprint\n",
    "\n",
    "# Build a dictionary of titles and distances for Urban Residents art\n",
    "art_distances = {}\n",
    "for row in art_dist_meters.iterrows():\n",
    "    vals = row[1]\n",
    "    key = vals['title']\n",
    "    ctr = vals['center']\n",
    "    art_distances[key] = vals['geometry'].distance(ctr)\n",
    "\n",
    "# Print the art_distances\n",
    "pprint.pprint(art_distances)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Folium\n",
    "- Lets you create interactive maps\n",
    "- Folium wants coordinates as at array, with lat first\n",
    "\n",
    "```python\n",
    "eiffel_tower = folium.Map(location = [48.8583736, 2.2922926], zoom_start=12)\n",
    "\n",
    "display(eiffel_tower)\n",
    "```\n",
    "\n",
    "### Create a folium location from the urban centroid\n",
    "In order to construct a folium map of the Urban Residents neighborhood, you need to build a coordinate pair location that is formatted for folium.\n",
    "\n",
    "Folium locations are arrays with latitude first. You just created a folium location from the center of the Urban Residents neighborhood."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the head of the urban_polygon\n",
    "print(urban_polygon.head())\n",
    "\n",
    "# Create urban_center from the urban_polygon center\n",
    "urban_center = urban_polygon.center[0]\n",
    "\n",
    "# Print urban_center\n",
    "print(urban_center)\n",
    "\n",
    "# Create array for folium called urban_location\n",
    "urban_location = [urban_center.y, urban_center.x]\n",
    "\n",
    "# Print urban_location\n",
    "print(urban_location)\n",
    "\n",
    "# Construct a folium map with urban_location\n",
    "downtown_map = folium.Map(location = urban_location, zoom_start = 15)\n",
    "\n",
    "# Display the map\n",
    "display(downtown_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array for called folium_loc from the urban_polygon center point\n",
    "point = urban_polygon.center[0]\n",
    "folium_loc = [point.y, point.x]\n",
    "\n",
    "# Construct a map from folium_loc: downtown_map\n",
    "downtown_map = folium.Map(location = folium_loc, zoom_start = 15)\n",
    "\n",
    "# Draw our neighborhood: Urban Residents\n",
    "folium.GeoJson(urban_polygon.geometry).add_to(downtown_map)\n",
    "\n",
    "# Display the map\n",
    "display(downtown_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding markers for the public art\n",
    "Now that you have added the polygon for the Urban Residents neighborhood to your folium street map, it's time to add the locations of the art within the neighborhood. You can do that by creating folium markers. Each marker needs a location assigned. Use iterrows() to loop through the data to grab the values you need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterate through the urban_art and print each part of tuple returned\n",
    "for row in urban_art.iterrows():\n",
    "  print('first part: ', row[0])\n",
    "  print('second part: ', row[1])\n",
    "\n",
    "# Create a location and marker with each iteration for the downtown_map\n",
    "for row in urban_art.iterrows():\n",
    "    row_values = row[1] \n",
    "    location = [row_values['lat'], row_values['lng']]\n",
    "    marker = folium.Marker(location = location)\n",
    "    marker.add_to(downtown_map)\n",
    "\n",
    "# Display the map\n",
    "display(downtown_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Troubleshooting data issues\n",
    "You will be building popups for the downtown art using the title and desc columns from the urban_art DataFrame. Here, you will inspect those columns to identify and clean up any problematic values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the urban_art titles\n",
    "print(urban_art.title)\n",
    "\n",
    "#Print the urban_art descriptions\n",
    "print(urban_art.desc)\n",
    "\n",
    "# Replace Nan and ' values in description\n",
    "urban_art.desc.fillna('', inplace = True)\n",
    "urban_art.desc = urban_art.desc.str.replace(\"'\", \"`\")\n",
    "\n",
    "#Print the urban_art descriptions again\n",
    "print(urban_art.desc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct downtown map\n",
    "downtown_map = folium.Map(location = nashville, zoom_start = 15)\n",
    "folium.GeoJson(urban_polygon).add_to(downtown_map)\n",
    "\n",
    "# Create popups inside the loop you built to create the markers\n",
    "for row in urban_art.iterrows():\n",
    "    row_values = row[1] \n",
    "    location = [row_values['lat'], row_values['lng']]\n",
    "    popup = (str(row_values['title']) + ': ' + \n",
    "             str(row_values['desc'])).replace(\"'\", \"`\")\n",
    "    marker = folium.Marker(location = location, popup = popup)\n",
    "    marker.add_to(downtown_map)\n",
    "\n",
    "# Display the map.\n",
    "display(downtown_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choropleth\n",
    "- Map using colour to show attributes of regions\n",
    "\n",
    "### Finding counts from a spatial join\n",
    "You will be using a dataset of the building permits issued in Nashville during 2017. This DataFrame called permits is in your workspace along with the council_districts GeoDataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from shapely.geometry import Point\n",
    "\n",
    "# Create a shapely Point from lat and lng\n",
    "permits['geometry'] = permits.apply(lambda x: Point((x.lng , x.lat)), axis = 1)\n",
    "\n",
    "# Build a GeoDataFrame: permits_geo\n",
    "permits_geo = gpd.GeoDataFrame(permits, crs = council_districts.crs, geometry = permits.geometry)\n",
    "\n",
    "# Spatial join of permits_geo and council_districts\n",
    "permits_by_district = gpd.sjoin(permits_geo, council_districts, op = 'within')\n",
    "print(permits_by_district.head(2))\n",
    "\n",
    "# Create permit_counts\n",
    "permit_counts = permits_by_district.groupby(['district']).size()\n",
    "print(permit_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an area column in council_districts\n",
    "council_districts['area'] = council_districts.geometry.area\n",
    "print(council_districts.head(2))\n",
    "\n",
    "# Convert permit_counts to a DataFrame\n",
    "permits_df = permit_counts.to_frame()\n",
    "print(permits_df.head(2))\n",
    "\n",
    "# Reset index and column names\n",
    "permits_df.reset_index(inplace=True)\n",
    "permits_df.columns = ['district', 'bldg_permits']\n",
    "print(permits_df.head(2))\n",
    "\n",
    "# Merge council_districts and permits_df: \n",
    "districts_and_permits = pd.merge(council_districts, permits_df, on = 'district')\n",
    "print(districts_and_permits.head(2))\n",
    "\n",
    "# Print the type of districts_and_permits\n",
    "print(type(districts_and_permits))\n",
    "\n",
    "# Create permit_density column in districts_and_permits\n",
    "districts_and_permits['permit_density'] = districts_and_permits.apply(lambda row: row.bldg_permits / row.area, axis = 1)\n",
    "\n",
    "# Print the head of districts_and_permits\n",
    "print(districts_and_permits.head(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Polished choropleth of building permit_density\n",
    "districts_and_permits.plot(column = 'permit_density', cmap = 'BuGn', edgecolor = 'black', legend = True)\n",
    "plt.xlabel('longitude')\n",
    "plt.ylabel('latitude')\n",
    "plt.xticks(rotation = 'vertical')\n",
    "plt.title('2017 Building Project Density by Council District')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Area in km squared, geometry in decimal degrees\n",
    "In this exercise, you'll start again with the council_districts GeoDataFrame and the permits DataFrame. You will change the council_districts to use the EPSG 3857 coordinate reference system before creating a column for area. Once the area column has been created, you will change the CRS back to EPSG 4326 so that the geometry is in decimal degrees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change council_districts crs to epsg 3857\n",
    "council_districts = council_districts.to_crs(epsg = 3857)\n",
    "print(council_districts.crs)\n",
    "print(council_districts.head())\n",
    "\n",
    "# Create area in square km\n",
    "sqm_to_sqkm = 10**6\n",
    "council_districts['area'] = council_districts.geometry.area / sqm_to_sqkm\n",
    "\n",
    "# Change council_districts crs back to epsg 4326\n",
    "council_districts = council_districts.to_crs(epsg = 4326)\n",
    "print(council_districts.crs)\n",
    "print(council_districts.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create permits_geo\n",
    "permits_geo = gpd.GeoDataFrame(permits, crs = council_districts.crs, geometry = permits.geometry)\n",
    "\n",
    "# Spatially join permits_geo and council_districts\n",
    "permits_by_district = gpd.sjoin(permits_geo, council_districts, op = 'within')\n",
    "print(permits_by_district.head(2))\n",
    "\n",
    "# Count permits in each district\n",
    "permit_counts = permits_by_district.groupby('district').size()\n",
    "\n",
    "# Convert permit_counts to a df with 2 columns: district and bldg_permits\n",
    "counts_df = permit_counts.to_frame()\n",
    "counts_df.reset_index(inplace=True)\n",
    "counts_df.columns = ['district', 'bldg_permits']\n",
    "print(counts_df.head(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a polished Geopandas choropleth\n",
    "After merging the counts_df with permits_by_district, you will create a column with normalized permit_density by dividing the count of permits in each council district by the area of that council district. Then you will plot your final geopandas choropleth of the building projects in each council district."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merge permits_by_district and counts_df\n",
    "districts_and_permits = pd.merge(permits_by_district, counts_df, on = 'district')\n",
    "\n",
    "# Create permit_density column\n",
    "districts_and_permits['permit_density'] = districts_and_permits.apply(lambda row: row.bldg_permits / row.area, axis = 1)\n",
    "print(districts_and_permits.head(2))\n",
    "\n",
    "# Create choropleth plot\n",
    "districts_and_permits.plot(column = 'permit_density', cmap = 'OrRd', edgecolor = 'black', legend = True)\n",
    "\n",
    "# Add axis labels and title\n",
    "plt.xlabel('longitude')\n",
    "plt.ylabel('latitude')\n",
    "plt.title('2017 Building Project Density by Council District')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Folium choropleth\n",
    "In this exercise, you will construct a folium choropleth to show the density of permitted construction projects in different Nashville council districts. You will be using a single data source, the districts_and_permits GeoDataFrame, which is in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Center point for Nashville\n",
    "nashville = [36.1636,-86.7823]\n",
    "\n",
    "# Create map\n",
    "m = folium.Map(location=nashville, zoom_start=10)\n",
    "\n",
    "# Build choropleth\n",
    "m.choropleth(\n",
    "    geo_data=districts_and_permits,\n",
    "    name='geometry',\n",
    "    data=districts_and_permits,\n",
    "    columns=['district', 'permit_density'],\n",
    "    key_on='feature.properties.district',\n",
    "    fill_color='Reds',\n",
    "    fill_opacity=0.5,\n",
    "    line_opacity=1.0,\n",
    "    legend_name='2017 Permitted Building Projects per km squared'\n",
    ")\n",
    "\n",
    "# Create LayerControl and add it to the map            \n",
    "folium.LayerControl().add_to(m)\n",
    "\n",
    "# Display the map\n",
    "display(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create center column for the centroid of each district\n",
    "districts_and_permits['center'] = districts_and_permits.geometry.centroid\n",
    "\n",
    "# Build markers and popups\n",
    "for row in districts_and_permits.iterrows():\n",
    "    row_values = row[1]\n",
    "    center_point = row_values['center']\n",
    "    location = [center_point.y, center_point.x]\n",
    "    popup = ('Council District: ' + str(row_values['district']) + \n",
    "             ';  ' + 'permits issued: ' + str(row_values['bldg_permits']))\n",
    "    marker = folium.Marker(location = location, popup = popup)\n",
    "    marker.add_to(m)\n",
    "    \n",
    "# Display the map\n",
    "display(m)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}