2_Earth_Engine_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0afbc091",
   "metadata": {},
   "source": [
    "# 2. Earth Engine Basics\n",
    "\n",
    "Module 1 is designed to give you basic skills to be able to find datasets you need for your project, filter them to your region of interest, apply basic processing and export the results. Mastering this will allow you to start using Earth Engine for your project quickly and save a lot of time pre-processing the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "07b05ee8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"600\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/kpfncBHZBto\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x7fd769ca72b0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo(id=\"kpfncBHZBto\", width=600, height=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "985faf0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%load_ext dotenv\n",
    "%autoreload 2\n",
    "%dotenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bef4cfea",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import geemap\n",
    "from geemap import Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d6d35dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ee\n",
    "ee.Initialize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f4c0e21",
   "metadata": {},
   "source": [
    "## 01. Hello World"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09102b6a",
   "metadata": {},
   "source": [
    "Let's familiarize ourselves with the basic syntax of Python + GEE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e81ef26d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print('Hello World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2cfdf4c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee.String({\n",
      "  \"constantValue\": \"Bengaluru\"\n",
      "}) ee.String({\n",
      "  \"constantValue\": \"India\"\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "# Variables\n",
    "city = ee.String(\"Bengaluru\")\n",
    "country = ee.String(\"India\")\n",
    "print(city, country)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "78943e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee.Number({\n",
      "  \"constantValue\": 8400000\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "population = ee.Number(8400000)\n",
    "print(population)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "39960144",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee.List({\n",
      "  \"constantValue\": [\n",
      "    \"Mumbai\",\n",
      "    \"Delhi\",\n",
      "    \"Chennai\",\n",
      "    \"Kolkata\"\n",
      "  ]\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "# List\n",
    "major_cities = ee.List([\"Mumbai\", \"Delhi\", \"Chennai\", \"Kolkata\"])\n",
    "print(major_cities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1bdb0f6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee.Dictionary({\n",
      "  \"constantValue\": {\n",
      "    \"city\": \"Bengaluru\",\n",
      "    \"elevation\": 930,\n",
      "    \"population\": 8400000\n",
      "  }\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "# Dictionary\n",
    "city_data = ee.Dictionary({\n",
    "    \"city\": city,\n",
    "    \"population\": population,\n",
    "    \"elevation\": 930\n",
    "})\n",
    "print(city_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8561c6fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Function\n",
    "greet = lambda name: f\"Hello {name}\"\n",
    "print(greet(\"World\"))\n",
    "\n",
    "# This is a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17ad0e3a",
   "metadata": {},
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "66169bdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ee.List({\n",
      "  \"constantValue\": [\n",
      "    \"Tokyo\",\n",
      "    \"Delhi\",\n",
      "    \"Shanghai\",\n",
      "    \"Mexico City\",\n",
      "    \"Sao Paulo\"\n",
      "  ]\n",
      "}) ['Tokyo', 'Delhi', 'Shanghai', 'Mexico City', 'Sao Paulo']\n"
     ]
    }
   ],
   "source": [
    "# These are the 5 largest cities in the world: \n",
    "# Tokyo, Delhi, Shanghai, Mexico City, Sao Paulo\n",
    "# Create a list named 'largeCities'\n",
    "large_cities = ee.List([\"Tokyo\", \"Delhi\", \"Shanghai\", \"Mexico City\", \"Sao Paulo\"])\n",
    "\n",
    "# The list should have names of all the above cities\n",
    "# Print the list \n",
    "print(large_cities, large_cities.getInfo())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0818bee7",
   "metadata": {},
   "source": [
    "## 02. Working with Image Collections\n",
    "\n",
    "Most datasets in Earth Engine come as an `ImageCollection`. An `ImageCollection` is a dataset that consists of images taken at different times and locations, usually from the same satellite or data provider. \n",
    "\n",
    "You can load a collection by searching the Earth Engine Data Catalog for the `ImageCollection` ID or from the map UI.\n",
    "\n",
    "Search for the Sentinel-2 Level 1C dataset and you will find its id `COPERNICUS/S2_SR`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1f16b613",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eb6ee8c8ece44c54ac4823113d659a13",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Map(center=[40, -100], controls=(WidgetControl(options=['position', 'transparent_bg'], widget=HBox(children=(T…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Init map to look for datasets\n",
    "m = Map()\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ee404f",
   "metadata": {},
   "source": [
    "Copy the code snippet associated with the data production and visualize the collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c144ffb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maskS2clouds(img):\n",
    "    \"\"\"Masks clouds using the Sentinel-2 QA bands.\n",
    "    \n",
    "    # Params\n",
    "        img (ee.Image).\n",
    "    \n",
    "    # Returns\n",
    "        masked_img (ee.Image).\n",
    "    \"\"\"\n",
    "    qa = img.select('QA60')\n",
    "\n",
    "    # Bits 10 and 11 are clouds and cirrus, respectively.\n",
    "    cloudBitMask = 1 << 10;\n",
    "    cirrusBitMask = 1 << 11;\n",
    "\n",
    "    # Both flags should be set to zero, indicating clear conditions.\n",
    "    mask = qa.bitwiseAnd(cloudBitMask).eq(0).And(qa.bitwiseAnd(cirrusBitMask).eq(0))\n",
    "\n",
    "    return img.updateMask(mask).divide(10000)\n",
    "\n",
    "\n",
    "# Mask 1 year of Sentinel-2 images.\n",
    "imgs = ee.ImageCollection(\"COPERNICUS/S2\")\\\n",
    "         .filterDate(\"2018-01-01\", \"2018-06-30\")\\\n",
    "         .filter(ee.Filter.lt(\"CLOUDY_PIXEL_PERCENTAGE\", 20))\\\n",
    "         .map(maskS2clouds)\n",
    "\n",
    "# Set visualization parameters\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 0.3,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "m.setCenter(-5.436518, 35.5850477, 12)\n",
    "m.addLayer(imgs.median(), viz, \"RGB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180bfc76",
   "metadata": {},
   "source": [
    "In the code snippet, You will see a function `m.setCenter()` which sets the viewport to a specific location and zoom level. The function takes the `X` coordinate (longitude), `Y` coordinate (latitude) and Zoom Level parameters. \n",
    "\n",
    "Replace the `X` and `Y` coordinates with the coordinates of your city and click Run to see the images of your city."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00c600d2",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Find the 'Sentinel-2 Level-2A' dataset.\n",
    "Copy/paste the code snippet\n",
    "\n",
    "Change the code to display images for your home city:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "17d50e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = ee.ImageCollection('COPERNICUS/S2_SR')\\\n",
    "             .filterDate('2020-01-01', '2020-06-30')\\\n",
    "             .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 20))\\\n",
    "             .map(maskS2clouds)\n",
    "\n",
    "# Set visualization parameters\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 0.3,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "# Set center on my city and visualize\n",
    "m.setCenter(-5.436518, 35.5850477, 12)\n",
    "m.addLayer(dataset.mean(), viz, \"L2-A RGB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a02eb1",
   "metadata": {},
   "source": [
    "## 03. Filtering Image Collections\n",
    "\n",
    "The original image collection contains all imagery ever collected by teh sensor. The entire collection is not very useful. Most applications require a subset of the images.\n",
    "\n",
    "We use filters to select the appropriate images. There are many types of filter functions. The `ee.Filter.*` modules contains all available filters. Select a filter then run the `filter()` function with its parameters.\n",
    "\n",
    "We will learn about 3 main types of filtering techniques:\n",
    "\n",
    "- Filter by metadata: uses filters such as `ee.Filter.eq()`, `ee.Filter.lt()`, etc. \n",
    "    - You can filter by PATH/ROW values, Orbit number, Cloud cover etc.\n",
    "- Filter by date: You can select images in a particular date range using filters such as `ee.Filter.date()`.\n",
    "- Filter by location: You can select the subset of images with a bounding box, location or geometry using the `ee.Filter.bounds()`. \n",
    "    - You can also use the drawing tools to draw a geometry for filtering.\n",
    "\n",
    "After applying the filters, you can use the size() function to check how many images match the filters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "63717696",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# Create a point of interest\n",
    "geometry = ee.Geometry.Point([77.60412933051538, 12.952912912328241])\n",
    "\n",
    "# Set the map center\n",
    "m.centerObject(geometry, 10)\n",
    "\n",
    "# Get the image collection\n",
    "s2 = ee.ImageCollection(\"COPERNICUS/S2\")\n",
    "\n",
    "# Filter by metadata\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\n",
    "\n",
    "# Filter by date\n",
    "filtered = filtered.filter(ee.Filter.date('2019-01-01', '2020-01-01'))\n",
    "\n",
    "# Filter by location\n",
    "filtered = filtered.filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "# Instead of applying filters one after the other, we can \"chain\" them\n",
    "# Use the `.` notation to apply all the filters together\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "             .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "             .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "# Print how many images we have after filtering\n",
    "print(filtered.size().getInfo())\n",
    "\n",
    "# Visualize\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "m.addLayer(filtered, viz, 'Filtered') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d540c352",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Add one more filter in the script below to select images from only one of the satellites: **Sentinel-2A**, from the Sentinel-2 constellation\n",
    "\n",
    "- Hint1: Use the 'SPACECRAFT_NAME' property\n",
    "- Hint2: Use the ee.Filter.eq() filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e6e7bbfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "geometry = ee.Geometry.Point([77.60412933051538, 12.952912912328241])\n",
    "\n",
    "m.centerObject(geometry, 10)\n",
    "\n",
    "imgs = ee.ImageCollection(\"COPERNICUS/S2\")\\\n",
    "         .filter(ee.Filter.lt(\"CLOUDY_PIXEL_PERCENTAGE\", 30))\\\n",
    "         .filter(ee.Filter.date(\"2019-01-01\", \"2020-01-01\"))\\\n",
    "         .filter(ee.Filter.geometry(geometry))\\\n",
    "         .filter(ee.Filter.eq(\"SPACECRAFT_NAME\", \"Sentinel-2A\"))\n",
    "\n",
    "print(imgs.size().getInfo())\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "m.addLayer(imgs.median(), viz, \"Filtered\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c822fa",
   "metadata": {},
   "source": [
    "## 04. Creating Mosaics and Composites from `ImageCollections`\n",
    "\n",
    "The default order of the collection is by **date**. So when you display the collection, it implicitly creates a mosaic with the latest pixels on top. You can call `.mosaic()` on an `ImageCollection` to create a mosaic image from the pixels at the top.\n",
    "\n",
    "We can also create a composite image by applying selection criteria to each pixel from all pixels in the stack. Here we use the `median()` function to create a composite where each pixel value is the median of all pixels from the stack.\n",
    "\n",
    "Tip: If you need to create a mosaic where the images are in a specific order, you can use the `.sort()` function to sort your collection by a property first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d45e9119",
   "metadata": {},
   "outputs": [],
   "source": [
    "geometry = ee.Geometry.Point([77.60412933051538, 12.952912912328241])\n",
    "s2 = ee.ImageCollection(\"COPERNICUS/S2\")\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "# Create the mosaic\n",
    "mosaic = filtered.mosaic()\n",
    " \n",
    "# Create the median composite\n",
    "median_composite = filtered.median()\n",
    "\n",
    "# Visualize\n",
    "m.addLayer(filtered, viz, 'Filtered Collection')\n",
    "m.addLayer(mosaic, viz, 'Mosaic')\n",
    "m.addLayer(median_composite, viz, 'Median Composite')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59e56e41",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Create a median composite for the year 2020 and load it to the map.\n",
    "\n",
    "Compare both the composites to see the changes in your city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "079a4bfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "geometry = ee.Geometry.Point([-5.436518, 35.5850477])\n",
    "s2 = ee.ImageCollection(\"COPERNICUS/S2\")\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2020-01-01', '2021-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "# Create the mosaic\n",
    "mosaic = filtered.mosaic()\n",
    " \n",
    "# Create the median composite\n",
    "median_composite = filtered.median()\n",
    "\n",
    "# Visualize\n",
    "m.setCenter(-5.436518, 35.5850477, 12)\n",
    "m.addLayer(mosaic, viz, 'Mosaic')\n",
    "m.addLayer(median_composite, viz, 'Median Composite')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94ea4d7e",
   "metadata": {},
   "source": [
    "## 05. Working with Feature Collections\n",
    "\n",
    "Feature Collections are similar to Image Collections, but they contain Features, not images. They are equivalent to Vector Layers in a GIS. We can load, filter and display Feature Collections using similar techniques that we have learned so far.\n",
    "\n",
    "Search for GAUL Second Level Administrative Boundaries and load the collection. This is a global collection that contains all Admin2 boundaries. We can apply a filter using the ADM1_NAME property to get all Admin2 boundaries (i.e. Districts) from a state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0f285b5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get administrative boundaries\n",
    "admins = ee.FeatureCollection(\"FAO/GAUL_SIMPLIFIED_500m/2015/level2\")\n",
    "\n",
    "# Filter \n",
    "karnataka = admins.filter(ee.Filter.eq('ADM1_NAME', 'Karnataka'))\n",
    "\n",
    "viz = {'color': 'red'}\n",
    "m.centerObject(karnataka)\n",
    "m.addLayer(karnataka, viz, 'Karnataka Districts')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d7b64fd",
   "metadata": {},
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3b60ea0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply a filter to select only the 'Bangalore Urban' district\n",
    "# Display only the selected district\n",
    "# Hint: The district names are in ADM2_NAME property\n",
    "admins = ee.FeatureCollection(\"FAO/GAUL_SIMPLIFIED_500m/2015/level2\")\n",
    "bangalore = admins.filter(ee.Filter.eq('ADM1_NAME', 'Karnataka')).filter(ee.Filter.eq(\"ADM2_NAME\", \"Bangalore Urban\"))\n",
    "\n",
    "viz = {\"color\": \"red\"}\n",
    "m.centerObject(bangalore)\n",
    "m.addLayer(bangalore, viz, 'bangalore')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9135ffd5",
   "metadata": {},
   "source": [
    "## 06. Importing Data\n",
    "\n",
    "You can import vector or raster data into Earth Engine. We will now import a shapefile of Urban Areas for Natural Earth. \n",
    "\n",
    "Unzip the `ne_10m_urban_areas.zip` into a folder on your computer.\n",
    "\n",
    "Let's import it to GEE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bd383322",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Upload\n",
    "shp_file_path = \"static/features/ne_10m_urban_areas.shp\"\n",
    "ee_object = geemap.shp_to_ee(shp_file_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cffd29e",
   "metadata": {},
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "651bf8da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Apply a filter to select only large urban areas\n",
    "# Use the property 'area_sqkm' and select all features \n",
    "# with area > 400 sq.km\n",
    "large_regions = ee_object.filter(ee.Filter.gt(\"area_sqkm\", 400))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "588ece5b",
   "metadata": {},
   "source": [
    "## 07. Clipping Images\n",
    "\n",
    "It is often desirable to clip the images to your area of interest. You can use the clip() function to mask out an image using a geometry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8ab0b56d",
   "metadata": {},
   "outputs": [],
   "source": [
    "s2 = ee.ImageCollection(\"COPERNICUS/S2\")\n",
    "urban = ee.FeatureCollection(\"users/ujavalgandhi/e2e/ne_10m_urban_areas\")\n",
    "\n",
    "# Find the feature id by adding the layer to the map and using Inspector.\n",
    "filtered = urban.filter(ee.Filter.eq('system:index', '00000000000000002bf8'))\n",
    "\n",
    "geometry = filtered.geometry()\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'], \n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "image = filtered.median() \n",
    "\n",
    "clipped = image.clip(geometry)\n",
    "\n",
    "m.centerObject(clipped)\n",
    "m.addLayer(clipped, viz, 'Clipped')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c9d8345",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "- Add the imported table to the Map\n",
    "- Use the Inspector to find the id of your home city or any urban area of your choice\n",
    "- Change the filter to use the id of the selected feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e5bdc8ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "urban = ee.FeatureCollection(\"users/ujavalgandhi/e2e/ne_10m_urban_areas\")\n",
    "\n",
    "# Find the feature id by adding the layer to the map and using Inspector.\n",
    "filtered = urban.filter(ee.Filter.eq('area_sqkm', 1116.547))\n",
    "\n",
    "m.addLayer(urban, {}, \"rois\")\n",
    "\n",
    "geometry = filtered.geometry()\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'], \n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "image = filtered.median() \n",
    "\n",
    "clipped = image.clip(geometry)\n",
    "\n",
    "m.addLayer(clipped, viz, 'Clipped')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4de9a14",
   "metadata": {},
   "source": [
    "## 08. Exporting Data\n",
    "\n",
    "Earth Engine allows for exporting both vector and raster data to be used in an external program. Vector data can be exported as a CSV or a Shapefile, while Rasters can be exported as GeoTIFF files. We will now export the Sentinel-2 Composite as a GeoTIFF file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0108354b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/9670fa78cd92e3c7fc14a461102a1541-5d8e3b8098831b6b5a24eb5ccf1eee3b:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to /Users/akramzaytar/projects/Learn/GEE/ezmap/notebooks/static/imgs/img.tif\n"
     ]
    }
   ],
   "source": [
    "s2 = ee.ImageCollection(\"COPERNICUS/S2\")\n",
    "urban = ee.FeatureCollection(\"users/ujavalgandhi/e2e/ne_10m_urban_areas\")\n",
    "filtered = urban.filter(ee.Filter.eq('area_sqkm', 1116.547))\n",
    "\n",
    "geometry = filtered.geometry()\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'], \n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "image = filtered.median()\n",
    "\n",
    "clipped = image.clip(geometry)\n",
    "\n",
    "m.addLayer(clipped, viz, 'Clipped') \n",
    "\n",
    "exportImage = clipped.select('B.*')\n",
    "\n",
    "# Export\n",
    "geemap.ee_export_image(exportImage, filename=\"static/imgs/img.tif\", scale=250, file_per_band=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "a4d967f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/3b2c75a228929775cac8e40ab4123fa9-4b3cd731aec019bce25ee8b605207144:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to /Users/akramzaytar/projects/Learn/GEE/ezmap/notebooks/static/imgs/viz_img.tif\n"
     ]
    }
   ],
   "source": [
    "# Rather than exporting raw bands, we can apply a rendered image\n",
    "# visualize() function allows you to apply the same parameters \n",
    "# that are used in earth engine which exports a 3-band RGB image\n",
    "visualized = clipped.visualize(**viz)\n",
    "\n",
    "# Now the 'visualized' image is RGB image, no need to give visParams\n",
    "m.addLayer(visualized, {}, 'Clipped')\n",
    "\n",
    "geemap.ee_export_image(visualized, filename=\"static/imgs/viz_img.tif\", scale=250, file_per_band=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d617d596",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write the export function to export the results for your chosen urban area:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "1009caa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/6ac11f7cfc8fa1592b6a93e9c7fc24dc-0c3b4617f8db6f23e105995ce9e41793:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to /Users/akramzaytar/projects/Learn/GEE/ezmap/notebooks/static/imgs/my_viz.tif\n"
     ]
    }
   ],
   "source": [
    "urban = ee.FeatureCollection(\"users/ujavalgandhi/e2e/ne_10m_urban_areas\")\n",
    "\n",
    "# Find the feature id by adding the layer to the map and using Inspector.\n",
    "filtered = urban.filter(ee.Filter.eq('area_sqkm', 1116.547))\n",
    "\n",
    "m.addLayer(urban, {}, \"rois\")\n",
    "\n",
    "geometry = filtered.geometry()\n",
    "\n",
    "viz = {\n",
    "  \"min\": 0.0,\n",
    "  \"max\": 3000,\n",
    "  \"bands\": ['B4', 'B3', 'B2'],\n",
    "}\n",
    "\n",
    "filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))\\\n",
    "    .filter(ee.Filter.date('2019-01-01', '2020-01-01'))\\\n",
    "    .filter(ee.Filter.geometry(geometry))\n",
    "\n",
    "image = filtered.median() \n",
    "\n",
    "clipped = image.clip(geometry)\n",
    "\n",
    "geemap.ee_export_image(clipped, filename=\"static/imgs/my_viz.tif\", scale=250, file_per_band=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c573abd7",
   "metadata": {},
   "source": [
    "# Assignment 1\n",
    "\n",
    "Export the Night Lights images for May,2015 and May,2020\n",
    "\n",
    "Workflow:\n",
    "1. [x] Load the VIIRS Nighttime Day/Night Band Composites collection\n",
    "2. [x] Filter the collection to the date range\n",
    "3. [x] Extract the 'avg_rad' band which represents the nighttime lights\n",
    "4. [x] Clip the image to the geometry of your city\n",
    "5. [x] Export the resulting image as a GeoTIFF file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "f1d0c093",
   "metadata": {},
   "outputs": [],
   "source": [
    "admins = ee.FeatureCollection('FAO/GAUL/2015/level2')\n",
    "tetouan = admins.filter(ee.Filter.eq(\"ADM2_CODE\", 21817))\n",
    "m.addLayer(tetouan, {}, \"FAO/GAUL/2015/level2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "b1707312",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load\n",
    "lights = ee.ImageCollection('NOAA/VIIRS/DNB/MONTHLY_V1/VCMCFG')\\\n",
    "    .filter(ee.Filter.date(\"2020-05-01\", \"2020-06-01\"))\\\n",
    "    .select([\"avg_rad\"]).first()\n",
    "\n",
    "tetouan_viz = lights.clip(tetouan.geometry())\n",
    "\n",
    "# Visualize\n",
    "m.addLayer(tetouan_viz, {}, \"Lights_2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "dd548802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/aee8ccc7a296045ac2ceba27856e890e-0a2baccd2a0453eed6d6e30889797179:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to /Users/akramzaytar/projects/Learn/GEE/ezmap/notebooks/static/imgs/my_lights.tif\n"
     ]
    }
   ],
   "source": [
    "geemap.ee_export_image(tetouan_viz, filename=\"static/imgs/my_lights.tif\", scale=250, file_per_band=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a71c0a4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "geemap.ee_search()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87ed06c9",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}