GEE Lab 2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "GEE Lab 2.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/andersknudby/Remote-Sensing/blob/master/GEE%20Lab%202.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrD5e3ItlOSl"
      },
      "source": [
        "#GEE Lab 2: Indices, Compositing, and Mosaicking in Google Earth Engine\n",
        "Developed by Genevieve George\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSD6EQTqpNfo"
      },
      "source": [
        "## Introduction\n",
        "\n",
        "In this lab we will continue working with the Google Earth Engine python API in Google Colab. \n",
        "We will learn how to calculate multi-spectral indices, and how to create composites and mosaic imagery.\n",
        "\n",
        "**Files you need:** N/A\n",
        "\n",
        "**Preparation:** Just keep up with the readings!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W1Ydjvj8pR4q"
      },
      "source": [
        "## Steps"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i-birGdTlidg"
      },
      "source": [
        "###| 1. Imports, installation, authentication, initialization\n",
        "\n",
        "Our first step is to get the notebook set up. Review the description in the first lab if you want a refresher on why we need to do this, and remember that you may get some warnings that you can ignore.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JqloY9sL4SdQ"
      },
      "source": [
        "# Install geemap library so that we can use it to view images on an interactive map\n",
        "## You may get a runtime warning - you can ignore that\n",
        "!pip install geemap"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BrNt-2X2eSxW"
      },
      "source": [
        "# Import the necessary libraries\n",
        "import ee\n",
        "import numpy as np\n",
        "import geemap as geemap\n",
        "import pprint\n",
        "\n",
        "# Set up a 'pretty printer' to print ...\n",
        "pp = pprint.PrettyPrinter(depth=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCgdEO86zQX5"
      },
      "source": [
        "# Authenticate and initialize this instance of GEE in Google Colab\n",
        "## Follow the prompts and fill in authentication code\n",
        "ee.Authenticate()\n",
        "ee.Initialize()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-mfqz8w53CR"
      },
      "source": [
        "### | 2. Indices\n",
        "\n",
        "#### Multispectral indices are calculated using simple **band math**. Recall that the Normalized Difference Vegetation Index (NDVI) is:\n",
        "\n",
        "```\n",
        "(NIR - RED) / (NIR + RED)\n",
        "```\n",
        "We can calculate any multi-spectral index as long as we are using a sensor that  has the bands we need. For example, we can easily calculate NDVI for Landsat 8, where Band 5 is the NIR band and Band 4 is the Red band:\n",
        "\n",
        "```\n",
        "NDVI = image.select('B5').subtract(image.select('B4')) \n",
        "          .divide(image.select('B5').add(image.select('B4')))\n",
        "```\n",
        "\n",
        "The `image.subtract(image2)`, `image.add(image2)`, and `image.divide(image2)` are all math functions that operate on two images. They are the equivalent of:\n",
        "\n",
        "`image - image2`\n",
        "\n",
        "`image + image2`\n",
        "\n",
        "`image / image2`\n",
        "\n",
        "These image math functions can be used to do any kind of band math you need to calculate a given index, or to calculate other kinds of band relationships.\n",
        "\n",
        "The `image.select()` function selects specified bands for an image as either a single band as with `image.select('B5')` or a list of bands like `image.select(['B5','B4'])`. Note that when you want to select multiple bands, you need to put them in a list with square brackets.\n",
        "\n",
        "By using `image.select(Band)`, we are making sure the raster math is done only with the bands we want to use within *the same image*, rather than with every band in two different images.\n",
        "\n",
        "\n",
        "####However, GEE also has a built in **“normalized difference”** function that saves several lines of code\n",
        "```\n",
        "NDVI = normalizedDifference('B5','B4')\n",
        "```\n",
        "This is a great way to calculate common normalized difference functions, but if you need to calculate other kinds of indices, you will still need to use the generic band math method.\n",
        "\n",
        "Let's try both of them out and visualize their outcomes. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rK56AcSE62wH"
      },
      "source": [
        "# First, import the Landsat 8 Tier 1 surface reflectance as a variable\n",
        "l8SR = ee.ImageCollection('LANDSAT/LC08/C01/T1_SR')\n",
        "\n",
        "# Create a point at Alfred Bog (east of Ottawa)\n",
        "point = ee.Geometry.Point([-74.8588,45.4839]) \n",
        "\n",
        "# Filter for images within our date range that overlap our point\n",
        "# sort by cloud cover and choose least cloudy (first)\n",
        "l8SR_Jul2019_LC = l8SR.filterBounds(point) \\\n",
        "                      .filterDate('2020-08-01', '2020-08-31') \\\n",
        "                      .sort('CLOUD_COVER') \\\n",
        "                      .first()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7RfAlnzCHHgP"
      },
      "source": [
        "Now that we have our image in the variable `l8SR_Jul2019_LC`, lets calculate NDVI both manually and using the normalized difference function.\n",
        "\n",
        "While working with an index that will be stored in a single band, we will want to use different visualization parameters than we have used so far with our multispectral images. \n",
        "\n",
        "The [GEE Documentation](https://developers.google.com/earth-engine/tutorials/tutorial_api_02) describes their colours as follows: \n",
        "\n",
        "\"The colors are defined using the web standard CSS color value scheme. Colors can be specified by name or as hexadecimal strings indicating the combination of red, green and blue. The lowest value in any of the three positions is 00 (representing the decimal number 0), while the highest is FF (representing the decimal number 255). The string '000000' represents the color black, 'FFFFFF' is white, 'FF0000' is red, '00FF00' is green, and '0000FF' is blue.\"\n",
        "\n",
        "See the [GEE page](https://developers.google.com/earth-engine/guides/image_visualization#color-palettes) on color palettes for more information.\n",
        "\n",
        "Also check out this [Google color picker tool](https://www.google.com/search?q=color+picker) which can be helpful when choosing your own palettes and colour schemes by hex#.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ySfE81g4HGZv"
      },
      "source": [
        "# Compute NDVI the manual way!\n",
        "NDVI_long = l8SR_Jul2019_LC.select('B5').subtract(l8SR_Jul2019_LC.select('B4')) \\\n",
        "               .divide(l8SR_Jul2019_LC.select('B5').add(l8SR_Jul2019_LC.select('B4')))\n",
        "\n",
        "#Using the Normalized difference function\n",
        "# note: The band is renamed to 'ndvi' as default is to add a band called 'nd' to the image\n",
        "NDVI = l8SR_Jul2019_LC.normalizedDifference(['B5', 'B4']).rename('ndvi'); \n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-rctevc-KEcl"
      },
      "source": [
        "In both methods, we create a new image in a new variable that contains **just** the ndvi band that we created. \n",
        "\n",
        "Let's check out the band names of both images to better understand the differences. \n",
        "\n",
        "The code `image.get()` gets the metaproperties of the image (in this case, we are interested in the property `system:band_names` which is the property that stores the name of the bands)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nFor7hPqLHVH"
      },
      "source": [
        "print('NDVI_long Bands:\\n',NDVI_long.get('system:band_names').getInfo())\n",
        "\n",
        "print('NDVI Bands:\\n',NDVI.get('system:band_names').getInfo())\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L4oDvF7kOuzb"
      },
      "source": [
        "In the long method, the band is called 'B5' because that is the band name that we selected from the original image and then did our calculations on. We could rename it if we want (in the same way we did for the normalized difference function) to make sure we keep track of what bands are what."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEZBUITWlgBr"
      },
      "source": [
        "Now let's visualize our NDVI indices, as well as the true colour image."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cVeF9kd7j1Mj"
      },
      "source": [
        "Map = geemap.Map()\n",
        "\n",
        "# Set the L8 true colour vis params\n",
        "L8_TC_vis = {\n",
        "  'bands': ['B4', 'B3', 'B2'],\n",
        "  'min': 0,\n",
        "  'max': 3000,\n",
        "  'gamma': 1.4,\n",
        "}\n",
        "\n",
        "# Recall that NDVI is a value between -1 and 1\n",
        "# We set the min in this case as 0.25 to better show the difference in our area\n",
        "# Feel free to play around and change the min to 0\n",
        "# The palette here are colours between white (FFFFFF) and green (006400)\n",
        "NDVI_vis = {'min': 0.25, 'max': 1, 'palette': ['FFFFFF', '006400']}\n",
        "\n",
        "Map.addLayer(l8SR_Jul2019_LC,L8_TC_vis,'l8SR_Jul2019_LC')\n",
        "Map.addLayer(NDVI_long, NDVI_vis, 'NDVI_long')\n",
        "Map.addLayer(NDVI, NDVI_vis, 'NDVI')\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(point,8)\n",
        "\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EeW_MiQU67X1"
      },
      "source": [
        "Both of them create the exact same map - which is good! That is what we expect.\n",
        "\n",
        "Now let's try a couple of other indices.\n",
        "*   Normalized Difference Water Index (NDWI)\n",
        "*   Normalized Difference Built-up Index (NDBI)\n",
        "*   Enhanced Vegetation Index (EVI)\n",
        "*   Built-up Index (BUI)\n",
        "*   Enhanced Vegetation Index (BAI)\n",
        "\n",
        "As we go, we will create a unique palette for each index that makes sense for what it is showing (e.g., greens for vegetation, blues for water, etc.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p_dcql1LpVgS"
      },
      "source": [
        "#NDWI = (GREEN – NIR) / (GREEN + NIR)\n",
        "NDWI = l8SR_Jul2019_LC.normalizedDifference(['B3', 'B5']).rename('ndwi')\n",
        "NDWI_vis = {'min': -1, 'max': 1, 'palette': ['00FFFF', '0000FF']}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YNBqSVyCpw-G"
      },
      "source": [
        "#NDBI = (SWIR – NIR) / (SWIR + NIR)\n",
        "NDBI = l8SR_Jul2019_LC.normalizedDifference(['B6', 'B5']).rename('ndbi')\n",
        "NDBI_vis = {'min': -1, 'max': 1, 'palette': ['1ee6dc', 'ff2b3d']}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z1B3cQZdwISb"
      },
      "source": [
        "#BUI = NDBI - NDVI\n",
        "BUI = NDBI.select('ndbi').subtract(NDVI.select('ndvi'))\n",
        "BUI_vis = {'min': -1, 'max': 1, 'palette': ['1ee6dc', 'ff2b3d']}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "11s8CWGr6gLJ"
      },
      "source": [
        "You can also create bands using a mathematical expression. In this method, the expression is written as a string where any variables can be defined as a second argument in the function. Check out the example below with the Enhanced Vegetation Index (EVI)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CJ54tOJKuOBT"
      },
      "source": [
        "#EVI = 2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))\n",
        "EVI = l8SR_Jul2019_LC.expression(\n",
        "    '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', {\n",
        "      'NIR': l8SR_Jul2019_LC.select('B5'),\n",
        "      'RED': l8SR_Jul2019_LC.select('B4'),\n",
        "      'BLUE': l8SR_Jul2019_LC.select('B2')\n",
        "})\n",
        "EVI_vis = {'min': -1, 'max': 1, 'palette': ['FFFFFF', '006400']}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "29sBRP4zv8KY"
      },
      "source": [
        "Now add all they layers to the map and see what they look like."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k6HPox6Lwd1H"
      },
      "source": [
        "Map = geemap.Map()\n",
        "\n",
        "Map.addLayer(NDVI, NDVI_vis, 'NDVI')\n",
        "Map.addLayer(NDWI, NDWI_vis, 'NDWI')\n",
        "Map.addLayer(NDBI, NDBI_vis, 'NDBI')\n",
        "Map.addLayer(BUI, BUI_vis, 'BUI')\n",
        "Map.addLayer(EVI, EVI_vis, 'EVI')\n",
        "\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(point,8)\n",
        "\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rx-NyzLR_HjY"
      },
      "source": [
        "###| 3. Compositing\n",
        "\n",
        "Compositing in Google Earth Engine is based on the process of 'reducing'. Reducers are a way to aggregate data over time, space, bands, etc. in GEE. \n",
        "\n",
        "If you have taken any other GIS/geomatics classes, you are probably familiar with the concept of zonal statistics, where the values of a raster are summarized into statistics (like mean, median, max, min, etc.) based on a 'zone' defined by either a polygon or another raster.\n",
        "\n",
        "Zonal statistics are an example of a spatial reduction, where values across an area are aggregated (summed, averaged, etc.), but reducers can also be used to summarize images and image collections temporally. This works by calculating a statistic based on a stack of overlapping pixels (say a stack of images from every day in July) to calculate a summary statistic (average surface reflectance in July) for each pixel in the image.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cvDcV_Qugci6"
      },
      "source": [
        "![Screen Shot 2021-02-26 at 10.53.54 AM.png](data:image/png;base64,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)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zxgf4tSBgfXV"
      },
      "source": [
        "For this lab, we will concentrate on using temporal reducers to aggregate a series of images. One of the major strengths of Google Earth Engine is its ability to easily and quickly process huge amounts of information (like a series of images).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MnUUfFDngTi5"
      },
      "source": [
        "#### Landsat 8 Cloud Free Composite\n",
        "\n",
        "We will create a Landsat 8 cloud-free summer composite. By creating an image composite rather than just cloud masking an image, it enables us to have a seamless cloud-free base for future analyses or visualization.\n",
        "\n",
        "To get a better idea of how this works, we will plot both the least cloudy image from Summer 2019 and the composite image from 2019.\n",
        "\n",
        "For this example we will use the median as our reducer. So, for each pixel in the image stack, the median pixel value will be used in the composite image."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m7jot7XV-dhS"
      },
      "source": [
        "# Assign Landsat 8 Surface Reflectance Image Collection to a variable\n",
        "\n",
        "L8_SR_T1 = ee.ImageCollection(\"LANDSAT/LC08/C01/T1_SR\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rd7hiiEg-GKd"
      },
      "source": [
        "# Define cloud masking function (same as last lab)\n",
        "\n",
        "def cloudMaskL8(image):\n",
        "  # Bits 3 and 5 are cloud shadow and cloud, respectively.\n",
        "  cloudShadowBitMask = 1 << 3 #select the cloud shadow bit location\n",
        "  cloudsBitMask = 1 << 5 # select the cloud bit location\n",
        "  # Get the pixel QA band.\n",
        "  qa = image.select('pixel_qa')\n",
        "  # Both flags should be set to zero, indicating clear conditions.\n",
        "  # this only keeps pixels were both the cloud and cloud shadow bits are set to 0\n",
        "  mask = qa.bitwiseAnd(cloudShadowBitMask).eq(0).And(qa.bitwiseAnd(cloudsBitMask).eq(0))\n",
        "  # Return the masked image, not scaled to reflectance, with the QA bands.\n",
        "  return image.updateMask(mask)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GlDn_kq--ZgX"
      },
      "source": [
        "Next, lets filter the image collection. Instead of using a geometry (point or polygon) to filter our image collection, this time we will use the path and row to ensure we are using images that are right on top of each other. All Landsat scenes cover one path/row combination, and path 15 / row 29 correspond to a scene covering the area south and east of Ottawa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EIB61-3mCiae"
      },
      "source": [
        "# Filter the collection and apply the cloud mask\n",
        "L8_Ottawa = L8_SR_T1.filterDate('2019-06-01', '2019-08-31')\\\n",
        "                        .filter(ee.Filter.eq('WRS_PATH', 15))\\\n",
        "                        .filter(ee.Filter.eq('WRS_ROW', 29))\\\n",
        "                        .map(cloudMaskL8)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LEczj0T-AIX2"
      },
      "source": [
        "# create a variable for the least cloudy image\n",
        "L8_Ottawa_LC = L8_Ottawa.sort('CLOUD_COVER').first()\n",
        "\n",
        "# Create the median composite\n",
        "L8_Ottawa_median = L8_Ottawa.reduce(ee.Reducer.median())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M-fLsKD3BKqL"
      },
      "source": [
        "Now that we have both the least cloud image, and the composite image, let's plot them to see how they turned out"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1jx2qvWfBKKO"
      },
      "source": [
        "# Note that when we reduced the image collection, the bands got renamed to add '_median' at the end\n",
        "# We could rename the bands but for now we will just define two different vis params to deal with it.\n",
        "\n",
        "VP_normal = {\n",
        "  'bands': ['B4', 'B3', 'B2'], #change these bands depending on what you want to see\n",
        "  'min': 0,   #these values are the min/max values for an L5_SR image\n",
        "  'max': 3000,\n",
        "  'gamma': 1.4,#gamma applies a correction/stretch to each band.  you can specify one value for each band, or one for all\n",
        "}\n",
        "\n",
        "VP_composite = {\n",
        "  'bands': ['B4_median', 'B3_median', 'B2_median'], #change these bands depending on what you want to see\n",
        "  'min': 0,   #these values are the min/max values for an L5_SR image\n",
        "  'max': 3000,\n",
        "  'gamma': 1.4,#gamma applies a correction/stretch to each band.  you can specify one value for each band, or one for all\n",
        "}\n",
        "\n",
        "Map = geemap.Map()\n",
        "Map.addLayer(L8_Ottawa_LC,VP_normal,'L8 Ottawa Least Cloudy Summer 2019')\n",
        "Map.addLayer(L8_Ottawa_median,VP_composite,'L8 Ottawa Composite Summer 2019')\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(ee.Geometry.Point([-74.91,44.61]),8)\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P_457egbDbnp"
      },
      "source": [
        "Use the layer collection to turn on and off the layers to compare them. \n",
        "\n",
        "As you can see, neither of the two layers is completely cloud-free (which isn't super surprising since our image collection actually only has 4 images), but it is clear from this example that by aggregating a number of images together, you can end up with a better overall image. \n",
        "\n",
        "The median reducer computes the median band value for each band for each pixel. In other words, the reducer is acting on each band of each image separately. This means that the pixels that comprise the final composite image don't necessarily match any pixel in the original images. For example, a pixel could be made up of the red band value from image1, the green band value from image2, the blue band value from image3, etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K-JY1OloI__s"
      },
      "source": [
        "Now let's try the same thing again with a larger image collection, to see if we get a fully cloud-free composite."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1L2JCMPDJFa1"
      },
      "source": [
        "# Filter the collection and apply the cloud mask\n",
        "L8_Ottawa = L8_SR_T1.filter(ee.Filter.eq('WRS_PATH', 15))\\\n",
        "                    .filter(ee.Filter.eq('WRS_ROW', 29))\\\n",
        "                    .filter(ee.Filter.Or(ee.Filter.And(ee.Filter.date('2017-06-01', '2017-08-31')),\n",
        "                                         ee.Filter.And(ee.Filter.date('2018-06-01', '2018-08-31')),\n",
        "                                         ee.Filter.And(ee.Filter.date('2019-06-01', '2019-08-31')),\n",
        "                                         ee.Filter.And(ee.Filter.date('2020-06-01', '2020-08-31'))))\\\n",
        "                    .map(cloudMaskL8)\n",
        "\n",
        "L8_Ottawa_median = L8_Ottawa.reduce(ee.Reducer.median())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5MprHB8ZJGDK"
      },
      "source": [
        "Map = geemap.Map()\n",
        "Map.addLayer(L8_Ottawa_median,VP_composite,'L8 Ottawa Summer Composite Summer (2017-2020)')\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(ee.Geometry.Point([-74.91,44.61]),8)\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ir5--HGTJ-2_"
      },
      "source": [
        "This time, with 19 images in the collection, we end up with a perfectly cloud free composite image."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7PjunHcL6Aw"
      },
      "source": [
        "#### Composite Pros and Cons"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VxGca4_vMCOO"
      },
      "source": [
        "Composites are great for creating cloud-free images over a certain area. This functionality is also much easier and faster than individually downloading each image from an image stack to make sure you have cloud-free usable pixels for all the areas you need.\n",
        "\n",
        "However, there are a couple of considerations you need to make when using composite imagery in Google Earth Engine. \n",
        "\n",
        "Arguably, the most important thing is that there is no longer any connection between your composite image and the image properties of the input images. This makes sense because the metaproperties, like cloud cover, are properties of the *image*, not of the individual pixels. Also, as mentioned earlier, the composite pixels do not even originate from one single image; they are *'frankenpixels'* of sorts because their value for each band could come from many different input pixels. \n",
        "\n",
        "It also means that there is data loss when aggregating images together. For example, once reduced in GEE, there is no way to tell which pixel in the composite image came from which original image, so information like solar zenith angle, date, and even sensor are no longer accessible.\n",
        "\n",
        "You also need to consider how the image will be used. Depending on how the image collection is aggregated, it can cover many months or even years of data. This is fine (and even super useful) if you are looking for general patterns, but it also means that the image is no longer useful for certain applications. For example, if you create an annual composite image of an agricultural area to assess crop types, the reduced pixels will not reflect the nuance in seasonal growth which could lead to misclassifications.\n",
        "\n",
        "In summary, reducers and composite imagery are powerful tools when used and interpreted properly, but they are also easy to misuse. It's important to always be aware of how a composite is calculated to ensure that it works for your purposes and to guard against reaching incorrect conclusions about the data. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vEQPXKyyRMV1"
      },
      "source": [
        "###| 4. Mosaicking"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fpT7BrctijQJ"
      },
      "source": [
        "Google Earth Engine does not have strict definitions of what compositing and mosaicking mean so they are often used interchangeably. This is partly because the processes often work together. The GEE documentation describes it like this:\n",
        "\n",
        "\n",
        "\n",
        "> \"In general, compositing refers to the process of combining spatially overlapping images into a single image based on an aggregation function. Mosaicking refers to the process of spatially assembling image datasets to produce a spatially continuous image.\"\n",
        "\n",
        "\n",
        "\n",
        "However, for the portions of the images that do overlap, mosaicking will choose which pixel should be included in the final mosaic image according to parameters the user determines. The process for determining the pixel follows the same temporal reducer process as compositing.\n",
        "\n",
        "Mosaics can be created in two ways:\n",
        "* using the mosaic functions, `.mosaic()` and `.qualityMosaic()`\n",
        "* using the reducer functions, `.reduce()`\n",
        "\n",
        "At this level, there are no functional differences between the two methods but we will introduce ourselves to how to use the simple mosaic, quality mosaic, and reducers to create mosaics.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lglYCcNSWuWr"
      },
      "source": [
        "#### Simple Mosaic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6nlNq_f2elZk"
      },
      "source": [
        "For the simple mosaic, we will choose two images that are beside each other (based on path and row) and mosaic them together. The `.mosaic()` function composites overlying images based on their order in the image collection. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CfPFk1-jejEG"
      },
      "source": [
        "# Create 2 specific images\n",
        "\n",
        "Image1 = ee.ImageCollection('LANDSAT/LT05/C01/T1_SR') \\\n",
        "                  .filterDate('2011-06-20', '2011-08-31') \\\n",
        "                  .filter(ee.Filter.eq('WRS_PATH', 15)) \\\n",
        "                  .filter(ee.Filter.eq('WRS_ROW', 29)) \\\n",
        "                  .sort('CLOUD_COVER') \\\n",
        "                  .first()\n",
        "\n",
        "\n",
        "Image2 = ee.ImageCollection('LANDSAT/LT05/C01/T1_SR') \\\n",
        "                  .filterDate('2011-06-20', '2011-08-31') \\\n",
        "                  .filter(ee.Filter.eq('WRS_PATH', 14)) \\\n",
        "                  .filter(ee.Filter.eq('WRS_ROW', 29)) \\\n",
        "                  .sort('CLOUD_COVER') \\\n",
        "                  .first()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R82P-b8ShDOu"
      },
      "source": [
        "# Create a new image collection with your two images\n",
        "\n",
        "images = ee.ImageCollection([Image1, Image2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y9WlNgKDhL9J"
      },
      "source": [
        "# Mosaic the image collection together\n",
        "\n",
        "mosaic = images.mosaic()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1Fgpl2MhnBj"
      },
      "source": [
        "# Display the mosaicked image\n",
        "\n",
        "Map = geemap.Map()\n",
        "visParams = {\n",
        "       'bands': ['B3', 'B2', 'B1'],\n",
        "       'min': 0,\n",
        "       'max': 2500,\n",
        "       'gamma': [0.95, 1.1, 1]\n",
        "     }\n",
        "\n",
        "Map.addLayer(mosaic, visParams, 'mosaic')\n",
        "Map.addLayer(Image1, visParams, 'image1')\n",
        "Map.addLayer(Image2, visParams, 'image2')\n",
        "\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(Image2,7)\n",
        "\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9ZbRGSTn9Bi"
      },
      "source": [
        "In the map above, toggle the layers on and off and see how the region of the mosaic where the two images overlap is all image2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63SFFhIWWxYD"
      },
      "source": [
        "#### Quality Mosaic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v05lN2_DyTMX"
      },
      "source": [
        "For the quality mosaic, we will use an image collection and a geometry and mosaic them together. Unlike the simple mosiac method which uses pixels from the top image where multiple images overlap, the `.qualityMosaic()` uses the pixel with the maximum value in a quality band that the user defines. For this example, we will create an NDVI band and use the 'greenest' pixel (the pixel with the maximum NDVI value) from the stack to create our mosaic. \n",
        "\n",
        "The choice of quality band depends on the intended use of the mosaic. For example, using NDVI works really well for a summertime mosaic because all kinds of things we typically don't want in images, like clouds, haze, and smoke, all tend to reduce NDVI. So picking the pixel with maximum NDVI also serves to *not* include all of those things in the moxaic. But it wouldn't necessarily  work well in the winter, where e.g. ice has higher NDVI than water. Other quality bands could be made from the date, where the most recent pixel is the best, or from the cloud cover score, or from an index like with NDVI. With this method, you need to ensure that the choice of quality band makes sense for your work."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OczS3DAxqsql"
      },
      "source": [
        "# Define the cloud mask\n",
        "\n",
        "def cloudMaskL457(image):\n",
        "  qa = image.select('pixel_qa')\n",
        "  # If the cloud bit (5) is set and the cloud confidence (7) is high\n",
        "  # or the cloud shadow bit is set (3), then it's a bad pixel.\n",
        "  cloud = qa.bitwiseAnd(1 << 5) \\\n",
        "                  .And(qa.bitwiseAnd(1 << 7))\n",
        "  mask2 = image.mask().reduce(ee.Reducer.min()); # remove edge pixels that don't occur in all bands\n",
        "  return image.updateMask(cloud.Not()).updateMask(mask2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "juGMcCcCqtSj"
      },
      "source": [
        "# Create a quality bands function incorporating the cloud mask function\n",
        "# We will apply this function across an image collection to use in the quality mosaic\n",
        "\n",
        "def addQualityBands(image):\n",
        "  image = cloudMaskL457(image)\n",
        "  image = image.addBands(image.normalizedDifference(['B4','B3']).rename('ndvi'))\n",
        "  return image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OL6T2J-Zqx4n"
      },
      "source": [
        "# Create polygon around Ottawa and Montreal\n",
        "polygon = ee.Geometry.Polygon([[-76.304,44.769],\n",
        "                           [-72.865,44.769],\n",
        "                           [-72.865,46.272],\n",
        "                           [-76.304,46.272],\n",
        "                           [-76.304,44.769]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l6JMMKH3ujKh"
      },
      "source": [
        "# Create the image collection\n",
        "# Map the quality band and cloud mask function\n",
        "# use the qualityMosaic function using the NDVI band\n",
        "Ottawa_Mosaic = ee.ImageCollection('LANDSAT/LT05/C01/T1_SR') \\\n",
        "                  .filterDate('2007-06-01', '2007-09-30')\\\n",
        "                  .filterBounds(polygon) \\\n",
        "                  .map(addQualityBands)\\\n",
        "                  .qualityMosaic('ndvi')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nsUl2ftLwxtP"
      },
      "source": [
        "# This piece of code clips the mosaic to the bounds of the polygon\n",
        "# This just cleans up the look of the mosaic and also eliminates information you may not need\n",
        "\n",
        "Ottawa_Mosaic_clipped = Ottawa_Mosaic.clip(polygon)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KHvsENtbw1oz"
      },
      "source": [
        "# Visualize the mosaic on the map\n",
        "Map = geemap.Map()\n",
        "visParams = {\n",
        "       'bands': ['B3', 'B2', 'B1'],\n",
        "       'min': 0,\n",
        "       'max': 3000,\n",
        "       'gamma': 1.4,\n",
        "     }\n",
        "\n",
        "Map.addLayer(Ottawa_Mosaic, visParams, 'L5 Ottawa Montreal Summer Mosaic',False) #don't display this layer on load\n",
        "Map.addLayer(Ottawa_Mosaic_clipped, visParams, 'L5 Ottawa Montreal Summer Mosaic (clipped)')\n",
        "\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(polygon,8) #center on the polygon at scale \"8\"\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BVg4RHQBW0Cf"
      },
      "source": [
        "#### Reducer Mosaic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pBSzMuEY7gXc"
      },
      "source": [
        "With this method, we will use the same function that we used for the composites earlier in the lab, but we will use an image collection with different paths and rows to see how the composite method works with overlapping areas and large extents."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ve2gz_1s8Jv5"
      },
      "source": [
        "# Define the cloud mask\n",
        "\n",
        "def cloudMaskL457(image):\n",
        "  qa = image.select('pixel_qa')\n",
        "  # If the cloud bit (5) is set and the cloud confidence (7) is high\n",
        "  # or the cloud shadow bit is set (3), then it's a bad pixel.\n",
        "  cloud = qa.bitwiseAnd(1 << 5) \\\n",
        "                  .And(qa.bitwiseAnd(1 << 7))\n",
        "  mask2 = image.mask().reduce(ee.Reducer.min()); # remove edge pixels that don't occur in all bands\n",
        "  return image.updateMask(cloud.Not()).updateMask(mask2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "deMP1cd59UpB"
      },
      "source": [
        "RMK_marinereserve = ee.Geometry.Polygon([[39.4862,-7.9000],\n",
        "                           [39.8219,-7.9000],\n",
        "                           [39.8219,-8.1335],\n",
        "                           [39.4862,-8.1335],\n",
        "                           [39.4862,-7.9000]])\n",
        "\n",
        "florida_keys = ee.Geometry.Polygon([[-81.5460,25.4011],\n",
        "                           [-79.961209,25.4011],\n",
        "                           [-79.961209,24.474241],\n",
        "                           [-81.5460,24.474241],\n",
        "                           [-81.5460,25.4011]])\n",
        "\n",
        "# try swapping out florida_keys for RMK_marinereserve to see another area\n",
        "# also change the zoom level (when adding to the map)\n",
        "polygon = RMK_marinereserve"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XRDIjM9q9a0d"
      },
      "source": [
        "# Create the image collection\n",
        "# Map the quality band and cloud mask function\n",
        "# use the qualityMosaic function using the NDVI band\n",
        "img_coll = ee.ImageCollection('LANDSAT/LT05/C01/T1_SR') \\\n",
        "                  .filterDate('2001', '2007')\\\n",
        "                  .filterBounds(polygon) \\\n",
        "                  .map(cloudMaskL457)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NOa2h-xt7fw_"
      },
      "source": [
        "mosaic = img_coll.reduce(ee.Reducer.median()).clip(polygon)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LkGJqRih-xx2"
      },
      "source": [
        "Map = geemap.Map()\n",
        "visParams = {\n",
        "       'bands': ['B3_median', 'B2_median', 'B1_median'],\n",
        "       'min': 0,\n",
        "       'max': 3000,\n",
        "       'gamma': 1.4,\n",
        "     }\n",
        "\n",
        "#Map.addLayer(Ottawa_Mosaic, visParams, 'L5 Ottawa Montreal Summer Mosaic',False) #don't display this layer on load\n",
        "Map.addLayer(mosaic, visParams, 'Keys')\n",
        "\n",
        "Map.addLayerControl()\n",
        "Map.centerObject(polygon,12) # change scale to 9 for floridakeys / 12 for RMK_marinereserve\n",
        "Map"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6KPRy-_lMk6O"
      },
      "source": [
        "## Questions to Submit\n",
        "Answer the following questions in the space provided. Feel free to add additional code and text cells as needed. Make sure to show all of your code.\n",
        "\n",
        "**In all cases**, if you use code chunks from another source (not a bad thing), make sure to reference where you found them.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ChwDTz1iV_w4"
      },
      "source": [
        "### Q1\n",
        "Use the Modified Normalized Difference Water Index (MNDWI) on the least cloudy Landsat 7 surface reflectance image over [Lake Claire, Alberta](https://www.google.com/maps/place/Lake+Claire/@58.5894117,-112.650579,9z/data=!3m1!4b1!4m5!3m4!1s0x53b705ccd903060f:0xee10bc1de8613758!8m2!3d58.620478!4d-112.1372149) for June 2002. Cloud-mask the images before calculating the MNDWI.\n",
        "\n",
        "Display both the true-colour cloud-masked image and the cloud-masked MNDWI on a map. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z1GfsFwlWeWD"
      },
      "source": [
        "## Show your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jEL4u63AWC6v"
      },
      "source": [
        "### Q2\n",
        "\n",
        "Create and display a cloud-free median composite image from Landsat 5 Surface Reflectance for path 9 row 28 from June 1st to August 31st for each year from 2005 to 2010 (inclusive).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8eWExaGKbKmd"
      },
      "source": [
        "## Show your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t5K_gHt_aKQE"
      },
      "source": [
        "### Q3\n",
        "\n",
        "What are some of the advantages and disadvantages of creating and using composite imagery? Describe a situation where you wouldn't want to use a composite image."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ArP1Oy42hW1H"
      },
      "source": [
        "// Write your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-XndL1U2b8G5"
      },
      "source": [
        "### Q4\n",
        "\n",
        "Create both a quality mosaic using NDVI and a composite mosaic using the median pixel for the following area over Victoria, British Columbia from Landsat 8 Surface Reflectance imagery from April 1st to September 30th, 2014. Cloud-mask the imagery before creating the composites.\n",
        "\n",
        "\n",
        "```\n",
        "victoria = ee.Geometry.Polygon([[-123.5427,48.6683],\n",
        "                           [-123.1009,48.6683],\n",
        "                           [-123.1009,48.3883],\n",
        "                           [-123.5427,48.3883],\n",
        "                           [-123.5427,48.6683]])\n",
        "```\n",
        "\n",
        "What are some differences between the two mosaics? Give at least 3. Which mosaicking method works better for this area and time period, and why?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CmfykgUJSr-g"
      },
      "source": [
        "## Show your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qd2B1P1-l-ht"
      },
      "source": [
        "// Write your answer here"
      ]
    }
  ]
}