ml_landcover_app.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wu-wB4TI7AHz"
      },
      "source": [
        "## Install packages"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#from google.colab import drive\n",
        "#drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "jT7R1xSCrJJH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install shap\n",
        "!pip install geemap\n",
        "\n",
        "!pip install geemap[extra]\n",
        "\n",
        "#!pip install geojson"
      ],
      "metadata": {
        "id": "uXKTvdfJG17n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import libraries"
      ],
      "metadata": {
        "id": "KwrkJimyG5DN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "import os, json\n",
        "\n",
        "import ipyleaflet\n",
        "\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display\n",
        "\n",
        "#from ipywidgets import Layout\n",
        "\n",
        "import ee\n",
        "import geemap\n",
        "\n",
        "#geemap.update_package()\n",
        "\n",
        "from pprint import pprint\n",
        "\n",
        "from google.colab import files\n",
        "#from google.colab import output\n",
        "#output.enable_custom_widget_manager()\n",
        "\n",
        "credentials_in_drive = 0\n",
        "if geemap.credentials_in_drive():\n",
        "  geemap.copy_credentials_to_colab()\n",
        "  credentials_in_drive = 1\n",
        "\n",
        "Map = geemap.Map()\n",
        "\n",
        "#if credentials_in_drive == 0 and geemap.credentials_in_colab():\n",
        "if geemap.credentials_in_colab():\n",
        "  geemap.copy_credentials_to_drive()\n",
        "\n",
        "pd.options.display.float_format = '{:,.2f}'.format"
      ],
      "metadata": {
        "id": "19RMVhDU-3E-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7I12SZn7jx_"
      },
      "source": [
        "## Widgets components"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#common widgets layout\n",
        "\n",
        "label_layout = widgets.Layout(display=\"flex\", justify_content=\"flex-end\", width=\"90%\")\n",
        "\n",
        "box_layout = widgets.Layout(display='flex',\n",
        "                flex_flow='column',\n",
        "                align_items='center')\n",
        "\n",
        "sidebar_layout = widgets.Layout(width='98%')\n",
        "\n",
        "desc_width = {'description_width': '120px'}"
      ],
      "metadata": {
        "id": "KUfOFt-eqQHg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Satellite and bands"
      ],
      "metadata": {
        "id": "4NEuwqVPX5kb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "satellite_list = [\n",
        "    'Landsat 7 SR',\n",
        "\n",
        "    'Landsat 8 SR',\n",
        "    'Landsat 9 SR',\n",
        "\n",
        "    'Landsat 7 TOA',\n",
        "\n",
        "    'Landsat 8 TOA',\n",
        "    'Landsat 9 TOA',\n",
        "    'Sentinel-2 SR',\n",
        "    'Sentinel-2 TOA']\n",
        "\n",
        "collections_list = [\n",
        "    'LANDSAT/LE07/C02/T1_L2',\n",
        "\n",
        "    'LANDSAT/LC08/C02/T1_L2',\n",
        "    'LANDSAT/LC09/C02/T1_L2',\n",
        "\n",
        "    'LANDSAT/LE07/C02/T1_TOA',\n",
        "    'LANDSAT/LC08/C02/T1_TOA',\n",
        "    'LANDSAT/LC09/C02/T1_TOA',\n",
        "    'COPERNICUS/S2_SR_HARMONIZED',\n",
        "    'COPERNICUS/S2_HARMONIZED']\n",
        "\n",
        "bands_list = [\n",
        "    ['SR_B'+str(i) for i in range(1,6)] + ['SR_B7', 'ST_B6'],\n",
        "    ['SR_B'+str(i) for i in range(1,8)] + ['ST_B10'],\n",
        "    ['SR_B'+str(i) for i in range(1,8)] + ['ST_B10'],\n",
        "\n",
        "    ['B'+str(i) for i in range(1,6)] + ['B7', 'B8'],\n",
        "    ['B'+str(i) for i in range(1,12)],\n",
        "    ['B'+str(i) for i in range(1,12)],\n",
        "    ['B'+str(i) for i in range(1,10)] + ['B8A', 'B11', 'B12'],\n",
        "    ['B'+str(i) for i in range(1,13)] + ['B8A'],\n",
        "]\n",
        "\n",
        "w_satellite = widgets.Dropdown(\n",
        "    options=satellite_list,\n",
        "    value='Landsat 9 SR',\n",
        "    description='Satellite',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "ind = satellite_list.index(w_satellite.value)\n",
        "\n",
        "w_select_bands = widgets.SelectMultiple(\n",
        "    options=bands_list[ind],\n",
        "    value=bands_list[ind][1:6],\n",
        "    rows=6,\n",
        "    description='Bands',\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout,\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "def satellite_handler(change):\n",
        "  ind = satellite_list.index(change.new)\n",
        "  #print(change.new, ', bands[{}]'.format(ind), bands_list[ind])\n",
        "  w_select_bands.options = bands_list[ind]\n",
        "  w_select_bands.value = bands_list[ind][1:6]\n",
        "\n",
        "w_satellite.observe(satellite_handler, names='value')\n",
        "\n",
        "#display(w_satellite, w_select_bands)\n"
      ],
      "metadata": {
        "id": "QQCXh0iYL5nN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Region of interest\n",
        "\n",
        "There are several ways you can create a region for generating the training dataset.\n",
        "\n",
        "- Draw a shape (e.g., rectangle) on the map and then use `region = Map.user_roi`\n",
        "- Define a geometry, such as `region = ee.Geometry.Rectangle([-122.6003, 37.4831, -121.8036, 37.8288])`\n",
        "- Create a buffer zone around a point, such as `region = ee.Geometry.Point([-122.4439, 37.7538]).buffer(10000)`\n",
        "- If you don't define a region, it will use the image footprint by default\n",
        "\n",
        "```\n",
        "image = (\n",
        "  ee.ImageCollection(collection)\n",
        "    .filterBounds(region)\n",
        "    .filterDate(start_date, end_date)\n",
        "    .map(maskL8sr)\n",
        "    .median()\n",
        "    .select(bands)\n",
        "    .clip(region)\n",
        ")\n",
        "```"
      ],
      "metadata": {
        "id": "ubc5emfSkKCN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "region_options = [\n",
        "    'Select an option', # if unselected, default to map bounds\n",
        "    'Draw shapes on map', # rectangle, polygon. If a point, use next option\n",
        "    'Input point and buffer', # input point coordinates and buffer distance\n",
        "    'Rectangle from BBox', # input bounding box coordinates\n",
        "    'Upload GeoJSON', # upload geometry in .GeoJSON\n",
        "    ]\n",
        "\n",
        "w_region = widgets.Dropdown(\n",
        "    options=region_options,\n",
        "    value='Select an option',\n",
        "    description='Region',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_region_detail = widgets.VBox()\n",
        "\n",
        "def regions_handler(change):\n",
        "  if change.new == 'Draw shapes on map':\n",
        "    w_region_detail.children = [widgets.Label(value=\"Please draw geometry on the map.\",\n",
        "                                              layout=label_layout)]\n",
        "\n",
        "  elif change.new == 'Input point and buffer':\n",
        "    w_point = widgets.Text(description='Lon, Lat',\n",
        "                           style=desc_width,\n",
        "                           layout=sidebar_layout)\n",
        "    w_buffer = widgets.FloatText(description='Buffer (km)',\n",
        "                                 style=desc_width,\n",
        "                                 layout=sidebar_layout)\n",
        "    w_region_detail.children = [w_point, w_buffer]\n",
        "\n",
        "  elif change.new == 'Rectangle from BBox':\n",
        "    w_points = widgets.Text(description='BBox (W, S, E, N)',\n",
        "                            style=desc_width,\n",
        "                            layout=sidebar_layout)\n",
        "    w_region_detail.children = [w_points]\n",
        "\n",
        "  elif change.new == 'Upload GeoJSON':\n",
        "    w_btn_region = widgets.Button(description='Upload GeoJSON',\n",
        "                            button_style='danger',\n",
        "                            tooltip=\"Upload GeoJSON\",\n",
        "                            #style={'font_size': '3px', 'font_weight': 'bold'}\n",
        "                            )\n",
        "\n",
        "    w_btn_region_output = widgets.Output()\n",
        "    def btn_region_handler(obj):\n",
        "        w_btn_region_output.clear_output()\n",
        "        with w_btn_region_output:\n",
        "          uploaded = files.upload()\n",
        "          for fn in uploaded.keys():\n",
        "            global region_json\n",
        "            region_json = fn\n",
        "            #print(region_json)\n",
        "\n",
        "    w_btn_region.on_click(btn_region_handler)\n",
        "    w_region_detail.children = [w_btn_region, w_btn_region_output]\n",
        "    #w_region_detail.layout = box_layout\n",
        "\n",
        "  else:\n",
        "    w_region_detail.children = [widgets.Label(\n",
        "        value=\"Default to current map boundary.\",\n",
        "        layout=label_layout)]\n",
        "\n",
        "w_region.observe(regions_handler, names='value')\n",
        "w_regions = widgets.VBox([w_region, w_region_detail])\n",
        "#display(w_regions)"
      ],
      "metadata": {
        "id": "B98CmtUWcGKA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### DatePicker & temporal interval"
      ],
      "metadata": {
        "id": "M8NjhgiLd-sy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# could use string as well\n",
        "w_start_date = widgets.DatePicker(\n",
        "    description='Start date',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_end_date = widgets.DatePicker(\n",
        "    description='End date',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_separate_doy = widgets.Checkbox(description='Separate doy from year',\n",
        "                                  value=False,\n",
        "                                  style=desc_width,\n",
        "                                  layout=sidebar_layout)\n",
        "\n",
        "w_temporal = widgets.Checkbox(description='Temporal composite',\n",
        "                              value=False,\n",
        "                              style=desc_width,\n",
        "                              layout=sidebar_layout)\n",
        "\n",
        "temporal_options = [\n",
        "    'All dates', # just median temporal composite of all scenes\n",
        "    'Yearly', # temporal composite for each year of all scenes\n",
        "    'Monthly', # temporal composite for each month of all scenes\n",
        "    'Daily', # temporal composite for each day of all scenes\n",
        "]\n",
        "\n",
        "w_temporal = widgets.Dropdown(\n",
        "    options=temporal_options,\n",
        "    value='All dates',\n",
        "    description='Composite interval',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_temporal_detail = widgets.VBox()\n",
        "\n",
        "def temporal_handler(change):\n",
        "  if change.new == 'All dates':\n",
        "    w_temporal_detail.children = [widgets.Label(value=\"Median composite for the entire interval\",\n",
        "                                                layout=label_layout)]\n",
        "  elif change.new == 'Yearly':\n",
        "    w_temporal_detail.children = [widgets.Label(value=\"Yearly median composite\",\n",
        "                                                layout=label_layout)]\n",
        "  elif change.new == 'Monthly':\n",
        "    w_temporal_detail.children = [widgets.Label(value=\"Monthly median composite\",\n",
        "                                                layout=label_layout)]\n",
        "  elif change.new == 'Daily':\n",
        "    w_temporal_detail.children = [widgets.Label(value=\"Daily mosaic\",\n",
        "                                                layout=label_layout)]\n",
        "\n",
        "w_temporal.observe(temporal_handler, names='value')\n",
        "\n",
        "w_dates = widgets.VBox([\n",
        "    w_start_date,\n",
        "    w_end_date,\n",
        "    #w_separate_doy,\n",
        "    w_temporal,\n",
        "    w_temporal_detail\n",
        "])\n"
      ],
      "metadata": {
        "id": "rn0KjzmGK11o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Spectal indices & other variables"
      ],
      "metadata": {
        "id": "tVy-rXkn75Hi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "w_spectral_indices = widgets.SelectMultiple(\n",
        "    options=['None', 'NDVI', 'NDWI', 'NBR'],\n",
        "    value=['None'],\n",
        "    description='Spectral indices',\n",
        "    rows=3,\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_variables = widgets.SelectMultiple(\n",
        "    options=['Elevation', 'Slope'],\n",
        "    value=[],\n",
        "    description='Other variables',\n",
        "    rows=3,\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_split_ratio = widgets.BoundedFloatText(\n",
        "    value=0.7,\n",
        "    min=0.1,\n",
        "    max=1,\n",
        "    step=0.01,\n",
        "    description='Split ratio',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")"
      ],
      "metadata": {
        "id": "hgoPCX0Z70vn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Multi-source checkbox\n",
        "\n",
        "If multi-source classification, select multiple satellites and their bands.\n",
        "```\n",
        "pprint(multiSource)\n",
        "\n",
        "{'Landsat 9 SR': ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6'],\n",
        " 'Sentinel-2 TOA': ['B2', 'B3', 'B4', 'B5', 'B6']}\n",
        "```"
      ],
      "metadata": {
        "id": "91ONYjDSHv0V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "w_multiSource = widgets.Checkbox(description='Multi-source',\n",
        "                                 value=False,\n",
        "                                 style=desc_width,\n",
        "                                 layout=sidebar_layout)\n",
        "\n",
        "# global variable: a dict storing satellite and bands lists for classification\n",
        "multiSource = {}\n",
        "\n",
        "def multiSourceChanged(value):\n",
        "    if value['new'] == True:\n",
        "      #w_btn_addSource.layout.visibility = \"visible\"\n",
        "      w_btn_addSource.layout.display = \"block\"\n",
        "      with w_btn_addSource_output:\n",
        "        print('Select satellite/bands, then click \"Add source\" button.')\n",
        "    else:\n",
        "      w_btn_addSource_output.clear_output()\n",
        "      multiSource.clear()\n",
        "      #w_btn_addSource.layout.visibility = \"hidden\"\n",
        "      w_btn_addSource.layout.display = \"none\"\n",
        "\n",
        "w_multiSource.observe(multiSourceChanged, names='value')\n",
        "\n",
        "w_btn_addSource = widgets.Button(description='Add source',\n",
        "                            button_style='danger',\n",
        "                            tooltip=\"Add satellite/bands\",\n",
        "                            #layout=widgets.Layout(visibility='hidden')\n",
        "                            layout=widgets.Layout(display='none')\n",
        "                            )\n",
        "\n",
        "w_btn_addSource_output = widgets.Output()\n",
        "def btn_addSource_handler(obj):\n",
        "    w_btn_addSource_output.clear_output()\n",
        "    with w_btn_addSource_output:\n",
        "      #print('Added satellite/bands for', w_satellite.value)\n",
        "      multiSource[w_satellite.value] = list(w_select_bands.value)\n",
        "      print('Current selection')\n",
        "      pprint(multiSource)\n",
        "\n",
        "w_btn_addSource.on_click(btn_addSource_handler)\n",
        "\n",
        "w_source = widgets.VBox([#widgets.HBox([w_multiSource, w_btn_addSource]),\n",
        "                         w_multiSource,\n",
        "                         w_btn_addSource,\n",
        "                         w_btn_addSource_output])\n",
        "\n",
        "if 0:\n",
        "  display(w_satellite, w_select_bands)\n",
        "  display(w_source)\n",
        "\n",
        "  #pprint(multiSource)\n",
        "  display(w_classifier)"
      ],
      "metadata": {
        "id": "TK5R4icB4NPp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classifier\n"
      ],
      "metadata": {
        "id": "D8Z2lrD2XfCO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "classifier_list = [\n",
        "    'CART',\n",
        "    'RandomForest',\n",
        "    #'NaiveBayes',\n",
        "    #'SVM',\n",
        "    #'decisionTree',\n",
        "]\n",
        "\n",
        "w_cart_param = [\n",
        "    widgets.BoundedIntText(\n",
        "        value=1000,\n",
        "        min=1,\n",
        "        max=1000,\n",
        "        step=1,\n",
        "        description='maxNodes',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "    widgets.BoundedIntText(\n",
        "        value=1,\n",
        "        min=1,\n",
        "        max=1000,\n",
        "        step=1,\n",
        "        description='minLeafPopulation',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "]\n",
        "\n",
        "w_rf_param = [\n",
        "    widgets.BoundedIntText(\n",
        "        value=100,\n",
        "        min=1,\n",
        "        max=1000,\n",
        "        step=1,\n",
        "        description='numberOfTrees',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "    widgets.BoundedIntText(\n",
        "        value=10,\n",
        "        min=1,\n",
        "        max=1000,\n",
        "        step=1,\n",
        "        description='variablesPerSplit',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "    widgets.BoundedIntText(\n",
        "        value=1,\n",
        "        min=1,\n",
        "        max=100,\n",
        "        step=1,\n",
        "        description='minLeafPopulation',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "    widgets.BoundedFloatText(\n",
        "        value=0.5,\n",
        "        min=0.01,\n",
        "        max=1,\n",
        "        step=0.01,\n",
        "        description='bagFraction',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "    widgets.BoundedIntText(\n",
        "        value=1000,\n",
        "        min=1,\n",
        "        max=1000,\n",
        "        step=1,\n",
        "        description='maxNodes',\n",
        "        disabled=True,\n",
        "        style=desc_width,\n",
        "        layout=sidebar_layout\n",
        "    ),\n",
        "]\n",
        "\n",
        "classifier_param ={\n",
        "    'CART': w_cart_param,\n",
        "    'RandomForest': w_rf_param\n",
        "}\n",
        "\n",
        "w_classifier_select = widgets.Dropdown(\n",
        "    options=classifier_list,\n",
        "    value='RandomForest',\n",
        "    description='Select classifier',\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_classifier_customize = widgets.Checkbox(description='Customize parameters',\n",
        "                                          value=False,\n",
        "                                          style=desc_width,\n",
        "                                          layout=sidebar_layout)\n",
        "\n",
        "w_classifier_param = widgets.VBox()\n",
        "\n",
        "#layout=widgets.Layout(border='1px solid black', justify_content='flex-end')\n",
        "\n",
        "def classifier_handler(change):\n",
        "  if w_classifier_customize.value:\n",
        "    w_classifier_param.children = classifier_param[change.new]\n",
        "    for w in w_classifier_param.children:\n",
        "      w.disabled=False\n",
        "\n",
        "w_classifier_select.observe(classifier_handler, names='value')\n",
        "\n",
        "def classifier_customizeChanged(value):\n",
        "    if value['new'] == False:\n",
        "      w_classifier_param.children=[]\n",
        "    else:\n",
        "      w_classifier_param.children = classifier_param[w_classifier_select.value]\n",
        "      for w in w_classifier_param.children:\n",
        "        w.disabled=False\n",
        "\n",
        "w_classifier_customize.observe(classifier_customizeChanged, names='value')\n",
        "\n",
        "w_classifier = widgets.VBox([w_classifier_select, w_classifier_customize, w_classifier_param],\n",
        "                            layout={'border': '1px solid green'})\n",
        "\n",
        "#display(w_classifier)"
      ],
      "metadata": {
        "id": "pROKhdF5XiHe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Widget output control on map"
      ],
      "metadata": {
        "id": "XYR1aO-_bi04"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "w_map_output = widgets.Output(layout={'border': '1px solid black',\n",
        "                                      #'width': '200px'\n",
        "                                      })\n",
        "output_control = ipyleaflet.WidgetControl(widget=w_map_output, position='bottomleft')\n",
        "Map.add_control(output_control)"
      ],
      "metadata": {
        "id": "ko5gxN9XboeX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Workflow buttons"
      ],
      "metadata": {
        "id": "KlQzciPVe_iZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Workflows:\n",
        "# check user input, load label/geometry data from csv,\n",
        "# filter image collections, get train/test data,\n",
        "# add layers to map, including labeled points and image\n",
        "# train/assess classifier,\n",
        "# classify image and display classification on map\n",
        "# examine feature importance: gee, scikit-learn, shap\n",
        "# calculate zonal statistics\n",
        "\n",
        "w_classified_flag = widgets.Checkbox(description='Image classified?', value=False)\n",
        "\n",
        "w_classified_tmpflag = widgets.Checkbox(description='Temporal composite classified?', value=False)\n",
        "\n",
        "w_btn_workflow_log = widgets.Output(layout={'border': '2px solid blue',\n",
        "                                            'height': '200px',\n",
        "                                            'overflow': 'auto'})\n",
        "\n",
        "w_btn_classify = widgets.Button(description='Classify',\n",
        "                           button_style='danger',\n",
        "                           tooltip=\"Filter image collection and classify image\",\n",
        "                           layout=widgets.Layout(width='80%'))\n",
        "\n",
        "def btn_classify_handler(obj):\n",
        "  w_btn_workflow_log.clear_output()\n",
        "  w_map_output.clear_output()\n",
        "\n",
        "  w_classified_flag.value = False\n",
        "  w_classified_tmpflag.value = False\n",
        "\n",
        "  with w_btn_workflow_log:\n",
        "    global imageMedian\n",
        "    print('Step 1/3: Get composite image')\n",
        "    imageMedian = getImage()\n",
        "\n",
        "    print('\\nStep 2/3: Get samples data')\n",
        "    getSamplesData(imageMedian)\n",
        "\n",
        "    print('\\nStep 3/3: Classify the image')\n",
        "    runGeeClassifier(imageMedian)\n",
        "    print('\\nDONE.')\n",
        "\n",
        "    w_classified_flag.value = True\n",
        "    w_map_output.clear_output()\n",
        "    # enable w_btn_features\n",
        "    w_btn_features.disabled=False\n",
        "\n",
        "w_btn_classify.on_click(btn_classify_handler)\n",
        "\n",
        "# w_feature_output is used to capture output of showFeatureImportance()\n",
        "#w_feature_output = widgets.Output()\n",
        "w_btn_features = widgets.Button(description='Feature importance',\n",
        "                           button_style='danger',\n",
        "                           disabled=True,\n",
        "                           tooltip=\"Calculate and display feature importance\")\n",
        "\n",
        "def btn_features_handler(obj):\n",
        "  ctab = showFeatureImportance()\n",
        "    #display(ctab)\n",
        "\n",
        "w_btn_features.on_click(btn_features_handler)"
      ],
      "metadata": {
        "id": "yH9HRRVilxT-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Samples from labeled points uploaded\n",
        "\n",
        "Upload csv file, each row represents a sample (lon, lat, class, date if any).\n",
        "\n",
        "There are some issues with widgets.FileUpload(). The Colab file.upload() is used instead."
      ],
      "metadata": {
        "id": "MrQD211-YF0s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_csv = None\n",
        "CLASS_NAMES = None\n",
        "CLASS_PALETTE = None\n",
        "\n",
        "w_btn_sample = widgets.Button(description='Upload samples',\n",
        "                            button_style='danger',\n",
        "                            tooltip=\"Sample format: (lon, lat, label, date)\",\n",
        "                            style=desc_width\n",
        "                            #layout=sidebar_layout\n",
        "                            )\n",
        "\n",
        "w_includeLabels = widgets.Checkbox(description='Class names included',\n",
        "                                   value=False,\n",
        "                                   style=desc_width, #layout=sidebar_layout\n",
        "                                   )\n",
        "\n",
        "w_class_labels = widgets.Text(\n",
        "    description='Class names',\n",
        "    placeholder='Comma-seperated names',\n",
        "    layout=widgets.Layout(width='98%'),\n",
        "    style=desc_width,\n",
        "    #layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_btn_sample_output = widgets.Output()\n",
        "def btn_sample_handler(obj):\n",
        "    w_btn_sample_output.clear_output()\n",
        "    with w_btn_sample_output:\n",
        "      uploaded = files.upload()\n",
        "\n",
        "      for fn in uploaded.keys():\n",
        "        # global file name\n",
        "        global sample_csv\n",
        "        sample_csv = fn\n",
        "      # read in sample_csv, display color picker for each class\n",
        "      #getLabelData(sample_csv)\n",
        "\n",
        "def includeLabelsChanged(value):\n",
        "    if value['new'] == True:\n",
        "      #w_class_labels.layout.visibility = \"hidden\"\n",
        "      w_class_labels.layout.display = \"none\"\n",
        "    else:\n",
        "      #w_btn_sample_output.clear_output()\n",
        "      #w_class_labels.layout.visibility = \"visible\"\n",
        "      w_class_labels.layout.display = \"block\"\n",
        "      # to-do: re-display after hidden, somehow the width not rendered properly\n",
        "      #w_class_labels.layout = widgets.Layout(display='block', width='98%')\n",
        "\n",
        "w_includeLabels.observe(includeLabelsChanged, names='value')\n",
        "\n",
        "w_btn_sample.on_click(btn_sample_handler)\n"
      ],
      "metadata": {
        "id": "29vGCBvHLQuF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "w_randomColors = widgets.Checkbox(\n",
        "    value=True,\n",
        "    description='Use random colors',\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_palette = widgets.VBox()\n",
        "\n",
        "def randomColorsChanged(value):\n",
        "  CLASS_NAMES, _ = getClassLabelsFromFile()\n",
        "\n",
        "  if CLASS_NAMES == None:\n",
        "    return\n",
        "\n",
        "  # Populate user-selected colors\n",
        "  if CLASS_PALETTE is not None:\n",
        "    random_colors = CLASS_PALETTE\n",
        "    #class_colors = [c.value for c in w_palette.children]\n",
        "  else:\n",
        "    random_colors=[\"#\"+''.join([random.choice('0123456789ABCDEF') for i in range(6)])\n",
        "          for j in range(len(CLASS_NAMES))]\n",
        "\n",
        "  w_palette.children = [widgets.ColorPicker(\n",
        "            concise=False,\n",
        "            description=name,\n",
        "            value=color,\n",
        "            disabled=False,\n",
        "            style=desc_width,\n",
        "            layout=sidebar_layout)\n",
        "    for (name, color) in zip(CLASS_NAMES, random_colors)\n",
        "  ]\n",
        "\n",
        "  if value['new'] == False:\n",
        "    w_palette.layout.display = \"block\"\n",
        "  else:\n",
        "    w_palette.layout.display = \"none\"\n",
        "    #w_palette.children = []\n",
        "\n",
        "w_randomColors.observe(randomColorsChanged, names='value')\n",
        "\n",
        "w_sample1 = widgets.VBox(\n",
        "    [#widgets.HBox([w_btn_sample, w_includeLabels]),\n",
        "    w_btn_sample,\n",
        "    w_btn_sample_output,\n",
        "    w_includeLabels,\n",
        "    w_class_labels,\n",
        "    w_randomColors,\n",
        "    w_palette]\n",
        ")\n"
      ],
      "metadata": {
        "id": "vbVgnqXVRHvH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Samples from LULC products"
      ],
      "metadata": {
        "id": "dQf1X7uXCIYB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "w_sample_select = widgets.Dropdown(\n",
        "    options=['Upload samples', 'Sample LULC products'],\n",
        "    value='Upload samples',\n",
        "    description='Labeled data',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "def sample_select_handler(change):\n",
        "  if change.new == 'Sample LULC products':\n",
        "    w_sample1.layout.display= \"none\"\n",
        "    w_sample2.layout.display= \"block\"\n",
        "  else:\n",
        "    w_sample2.layout.display= \"none\"\n",
        "    w_sample1.layout.display= \"block\"\n",
        "  # Clear output widgets\n",
        "  w_btn_workflow_log.clear_output()\n",
        "  w_map_output.clear_output()\n",
        "\n",
        "w_sample_select.observe(sample_select_handler, names='value')\n",
        "\n",
        "lulc_list = [\n",
        "    'Dynamic World V1',\n",
        "    'ESA WorldCover 10m v100/200',\n",
        "    'ESRI Global Land Cover',\n",
        "]\n",
        "\n",
        "w_lulc_select = widgets.Dropdown(\n",
        "    options=lulc_list,\n",
        "    value='Dynamic World V1',\n",
        "    description='LULC map',\n",
        "    disabled=False,\n",
        "    style=desc_width,\n",
        "    layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_numPoints = widgets.BoundedIntText(\n",
        "  value=1000,\n",
        "  min=100,\n",
        "  max=100000,\n",
        "  step=100,\n",
        "  description='Labels total',\n",
        "  style=desc_width,\n",
        "  layout=sidebar_layout\n",
        ")\n",
        "\n",
        "w_stratifiedSample = widgets.Checkbox(value=False,\n",
        "                                      description='Stratified sample',\n",
        "                                      style=desc_width,\n",
        "                                      layout=sidebar_layout)\n",
        "\n",
        "def stratifiedSampleChanged(value):\n",
        "    if value['new'] == True:\n",
        "      w_numPoints.description = 'Labels per class'\n",
        "    else:\n",
        "      w_numPoints.description = 'Labels total'\n",
        "\n",
        "w_stratifiedSample.observe(stratifiedSampleChanged, names='value')\n",
        "\n",
        "w_sample2 = widgets.VBox([w_lulc_select, w_stratifiedSample, w_numPoints],\n",
        "                         layout=widgets.Layout(display='none'))\n",
        "\n",
        "w_sample = widgets.VBox([w_sample_select,\n",
        "                         w_sample1,\n",
        "                         w_sample2])\n"
      ],
      "metadata": {
        "id": "NzYf8WcUCPvo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@w_btn_workflow_log.capture(clear_output=False, wait=False)\n",
        "def getClassLabelsFromFile():\n",
        "  \"\"\" Read labels for csv files uploaded \"\"\"\n",
        "  #sample_csv = 'landcover_google_sample.csv'\n",
        "\n",
        "  global LABEL, CLASS_NAMES, LABEL_DATA\n",
        "\n",
        "  if (w_includeLabels.value == False and w_class_labels.value == ''):\n",
        "    print('Incomplete input. If sample file does not include class names, enter them as a comma-separated list.')\n",
        "    return None, None\n",
        "  if sample_csv is None:\n",
        "    print('Upload samples first.')\n",
        "    return None, None\n",
        "\n",
        "  label_points = pd.read_csv(sample_csv)\n",
        "\n",
        "  LABEL = label_points.columns[2]\n",
        "\n",
        "  #Example CLASS_NAMES = ['Urban', 'Vegetation', 'Water']\n",
        "  CLASS_NAMES = label_points.iloc[:,2].unique()\n",
        "  CLASS_NAMES.sort()\n",
        "  CLASS_NAMES = CLASS_NAMES.tolist()\n",
        "\n",
        "  if w_includeLabels.value == False:\n",
        "    # Read in class names\n",
        "    CLASS_NAMES = w_class_labels.value.split(',')\n",
        "\n",
        "  # Remove possible leading/trailing white spaces\n",
        "  CLASS_NAMES = [s.strip() for s in CLASS_NAMES]\n",
        "  #print('Unique labels-class names:', CLASS_NAMES)\n",
        "\n",
        "  for i, name in enumerate(CLASS_NAMES):\n",
        "    if w_includeLabels.value:\n",
        "      # assign class names to 0-indexed consecutive integers\n",
        "      label_points.loc[label_points[LABEL]==name, LABEL] = i\n",
        "    else:\n",
        "      # already 0-indexed integers\n",
        "      pass\n",
        "      # assign class names\n",
        "      #label_points.loc[label_points[LABEL]==i, LABEL] = name\n",
        "\n",
        "  # check class balance\n",
        "  #class_count = label_points.groupby(LABEL)[LABEL].count()\n",
        "  #class_count.index = CLASS_NAMES\n",
        "  #print(class_count)\n",
        "\n",
        "  #LABEL_DATA = geemap.df_to_ee(label_points, latitude='lat', longitude='lon')\n",
        "  LABEL_DATA = geemap.df_to_ee(label_points,\n",
        "                              latitude=label_points.columns[1],\n",
        "                              longitude=label_points.columns[0])\n",
        "  #pprint(LABEL_DATA.first().getInfo())\n",
        "\n",
        "  return CLASS_NAMES, LABEL_DATA\n"
      ],
      "metadata": {
        "id": "yhqYvgrQU_UK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getClassLabelsFromLC():\n",
        "  \"\"\" Sample exisiting LULC products for labels \"\"\"\n",
        "\n",
        "  global LABEL, CLASS_NAMES, LABEL_DATA, CLASS_PALETTE\n",
        "\n",
        "  from geemap import legends\n",
        "\n",
        "  if w_lulc_select.value == 'Dynamic World V1':\n",
        "    legend = geemap.legends.builtin_legends['Dynamic_World']\n",
        "  elif w_lulc_select.value == 'ESA WorldCover 10m v100/200':\n",
        "    legend = geemap.legends.builtin_legends['ESA_WorldCover']\n",
        "  elif w_lulc_select.value == 'ESRI Global Land Cover':\n",
        "    legend = geemap.legends.builtin_legends['ESRI_LandCover_TS']\n",
        "\n",
        "  LABEL = 'Land cover' # hard-coded\n",
        "  CLASS_NAMES = [name.split(' ', 1)[1] for name in legend.keys()]\n",
        "  CLASS_LABELS = [int(name.split(' ', 1)[0]) for name in legend.keys()]\n",
        "  CLASS_PALETTE = list(legend.values())\n",
        "  CLASS_PALETTE = ['#'+c for c in CLASS_PALETTE if not c.startswith('#')]\n",
        "\n",
        "  # Sample LULC products selected\n",
        "  if w_lulc_select.value == 'Dynamic World V1':\n",
        "    # If no clip region\n",
        "    #lc = geemap.dynamic_world(region, start_date, end_date, return_type='class')\n",
        "    # If clip region\n",
        "    lc = geemap.dynamic_world(region, start_date, end_date, True, return_type='class')\n",
        "\n",
        "    # Rename band 'label_mode'. No need to remap since dynamic world is 0-indexed labels\n",
        "    lc = lc.rename(LABEL)\n",
        "\n",
        "  elif w_lulc_select.value == 'ESA WorldCover 10m v100/200':\n",
        "    if start_date.split('-')[0] == '2020':\n",
        "      lc = ee.Image('ESA/WorldCover/v100/2020')\n",
        "    elif start_date.split('-')[0] == '2021':\n",
        "      lc = ee.Image('ESA/WorldCover/v200/2021')\n",
        "    else:\n",
        "      # Still use 2021 for other years\n",
        "      print('ESA WorldCover 10m valid years: 2020-2021. Year 2021 used instead.')\n",
        "      lc = ee.Image('ESA/WorldCover/v200/2021')\n",
        "\n",
        "    # Remap labels and rename band\n",
        "    remapped_labels = list(range(0, len(CLASS_LABELS)))\n",
        "    #lc = lc.remap(CLASS_LABELS, remapped_labels).rename(LABEL).toByte()\n",
        "    lc = lc.clip(region).remap(CLASS_LABELS, remapped_labels).rename(LABEL)\n",
        "\n",
        "  elif w_lulc_select.value == 'ESRI Global Land Cover':\n",
        "    #lc = ee.ImageCollection(\"projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m\")\n",
        "    lc = ee.ImageCollection(\"projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m_TS\")\n",
        "\n",
        "    # Filter dates: seems the filter only works for the entire year 2017-2021\n",
        "    year = start_date.split('-')[0]\n",
        "    if year >= '2017' and year <= '2021':\n",
        "      pass\n",
        "    else:\n",
        "      year = '2021'\n",
        "      print('ESRI Global Land Cover valid years 2017-2021. Year 2021 used instead.')\n",
        "    lc = lc.filterDate(year+'-01-01', year+'-12-31').mosaic().clip(region)\n",
        "\n",
        "    # Remap labels and rename band\n",
        "    remapped_labels = list(range(0, len(CLASS_LABELS)))\n",
        "    lc = lc.remap(CLASS_LABELS, remapped_labels).rename(LABEL)\n",
        "\n",
        "  if w_stratifiedSample.value:\n",
        "    print('Stratified sampling', w_lulc_select.value, '...')\n",
        "    LABEL_DATA = lc.stratifiedSample(\n",
        "        **{\n",
        "            'numPoints': w_numPoints.value,\n",
        "            'classBand': LABEL,\n",
        "            'region': region,\n",
        "            'scale': 10,\n",
        "            'seed': seed,\n",
        "            'geometries': True,  # Set this to False to ignore geometries\n",
        "        }\n",
        "    )\n",
        "  else:\n",
        "    print('Random sampling', w_lulc_select.value, '...')\n",
        "    LABEL_DATA = lc.sample(\n",
        "        **{\n",
        "            'region': region,\n",
        "            'numPixels': w_numPoints.value,\n",
        "            'scale': 10,\n",
        "            'seed': seed,\n",
        "            'geometries': True,\n",
        "            'tileScale': 16\n",
        "        }\n",
        "    )\n",
        "\n",
        "  # Add layers: landcover lc and samples LABEL_DATA\n",
        "  vis_param = {'min': 0, 'max': len(CLASS_PALETTE)-1, 'palette': CLASS_PALETTE}\n",
        "  Map.addLayer(lc, vis_param, w_lulc_select.value)\n",
        "\n",
        "  w_map_output.clear_output()\n",
        "  with w_map_output:\n",
        "    text = 'Added LULC layer to sample from.'\n",
        "    htmlWidget = widgets.HTML(value = f\"<b><font color='red'>{text}</b>\")\n",
        "    display(htmlWidget)\n",
        "\n",
        "  return LABEL_DATA, CLASS_PALETTE\n"
      ],
      "metadata": {
        "id": "JzVZmqOhp-nm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Workflow functions"
      ],
      "metadata": {
        "id": "xecXKec8n5Yi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get ROI"
      ],
      "metadata": {
        "id": "dmQkShBWkzQ2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "region_options = [\n",
        "    'Select an option', # default to map bounds\n",
        "    'Draw shapes on map', # rectangle, polygon. If a point, use next option\n",
        "    'Input point and buffer', # input point coordinates and buffer distance\n",
        "    'Rectangle from BBox', # input bounding box coordinates\n",
        "    'Upload GeoJSON', # upload geometry in .geojson\n",
        "    ]\n",
        "\n",
        "    with open(os.path.abspath(region_json), encoding=\"utf-8\") as f:\n",
        "      geo_json = json.load(f)\n",
        "\n",
        "    if geo_json[\"type\"] == \"FeatureCollection\":\n",
        "      region = ee.FeatureCollection(geo_json)\n",
        "    elif geo_json[\"type\"] == \"Feature\":\n",
        "      region = ee.Geometry(geo_json['geometry'])\n",
        "\"\"\"\n",
        "\n",
        "def getRegion():\n",
        "  if w_region.value == 'Draw shapes on map':\n",
        "    print('Use geometry drawn on map')\n",
        "    region = Map.user_roi\n",
        "\n",
        "  elif w_region.value == 'Input point and buffer (km)':\n",
        "    w_point, w_buffer = w_region_detail.children\n",
        "    coord = w_point.value.split(',')\n",
        "    coord = [float(a) for a in coord[:2]]\n",
        "    region = ee.Geometry.Point(coord).buffer(w_buffer.value*1000)\n",
        "\n",
        "  elif w_region.value == 'Rectangle from BBox':\n",
        "    w_points = w_region_detail.children[0]\n",
        "    poly_coord = w_points.value.split(',')\n",
        "    poly_coord = [float(a) for a in poly_coord]\n",
        "    #region = ee.Geometry.Polygon(poly_coord)\n",
        "    region = ee.Geometry.BBox(*poly_coord)\n",
        "\n",
        "  elif w_region.value == 'Upload GeoJSON':\n",
        "    #? fixed - geemap could not convert features to ee.geometry\n",
        "    # however, it could convert feature collections\n",
        "    region = geemap.geojson_to_ee(region_json)\n",
        "\n",
        "  elif w_region.value == 'Select an option':\n",
        "    #region = ee.Geometry(Map.get_bounds(asGeoJSON=True))\n",
        "    region = ee.Geometry.BBox(*Map.get_bounds())\n",
        "  else:\n",
        "    region = None\n",
        "\n",
        "  return region"
      ],
      "metadata": {
        "id": "0IwqXkRXyJCG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cloud mask and image scaling\n"
      ],
      "metadata": {
        "id": "Cr-hjfFukst5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cloud masking function.\n",
        "def maskL89C2coulds(image):\n",
        "  # For collection 1\n",
        "  #cloudShadowBitMask = ee.Number(2).pow(3).int()\n",
        "  #cloudsBitMask = ee.Number(2).pow(5).int()\n",
        "  #qa = image.select('pixel_qa')\n",
        "\n",
        "  # For collection 2\n",
        "  #cloudShadowBitMask = ee.Number(2).pow(4).int()\n",
        "  #cloudsBitMask = ee.Number(2).pow(3).int()\n",
        "  #qa = image.select('QA_PIXEL')\n",
        "  #mask = qa.bitwiseAnd(cloudShadowBitMask).eq(0).And(\n",
        "  #  qa.bitwiseAnd(cloudsBitMask).eq(0))\n",
        "\n",
        "  qaMask = image.select('QA_PIXEL').bitwiseAnd(int('11111',2)).eq(0)\n",
        "  saturationMask = image.select('QA_RADSAT').eq(0)\n",
        "\n",
        "  return image.updateMask(qaMask).updateMask(saturationMask) \\\n",
        "              .copyProperties(image, ['system:time_start'])\n",
        "\n",
        "def applyL89srScale(image):\n",
        "  #LANDSAT 8/9 C02/T1_L2, surface reflectance\n",
        "  opticalBands = image.select('SR_B.').multiply(0.0000275).add(-0.2)\n",
        "  thermalBands = image.select('ST_B.*').multiply(0.00341802).add(149.0)\n",
        "  return image.addBands(opticalBands, None, True) \\\n",
        "              .addBands(thermalBands, None, True) \\\n",
        "              .copyProperties(image, ['system:time_start'])\n",
        "\n",
        "def maskS2clouds(image):\n",
        "  qa = image.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(\n",
        "      qa.bitwiseAnd(cirrusBitMask).eq(0))\n",
        "\n",
        "  return image.updateMask(mask).divide(10000) \\\n",
        "              .copyProperties(image, ['system:time_start'])"
      ],
      "metadata": {
        "id": "qabgYMq_nPET"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Filter ImageCollection\n"
      ],
      "metadata": {
        "id": "GlWaVq9eyAii"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def filterImageCollection(collection, region, start_date, end_date, bands, return_type='image'):\n",
        "  \"\"\"return either an median composite image or an image collection\n",
        "  \"\"\"\n",
        "\n",
        "  image = ee.ImageCollection(collection) \\\n",
        "            .filterDate(start_date, end_date)\n",
        "\n",
        "  # check if image is empty\n",
        "  #print('filtered image collection size: ', image.size().getInfo())\n",
        "\n",
        "  if region is not None:\n",
        "    image = image.filterBounds(region)\n",
        "\n",
        "  if collection.startswith('COPERNICUS/S2'):\n",
        "    image = image.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 20)) \\\n",
        "                 .map(maskS2clouds)\n",
        "  elif collection.startswith('LANDSAT/L'): # add Landsat 7\n",
        "    image = image.map(maskL89C2coulds)\n",
        "  else:\n",
        "    pass\n",
        "\n",
        "  # for landsat sr\n",
        "  if collection.endswith('T1_L2'):\n",
        "    image = image.map(applyL89srScale)\n",
        "\n",
        "  image = image.select(bands)\n",
        "\n",
        "  if return_type == 'image':\n",
        "    image = image.median()\n",
        "    if region is not None:\n",
        "      if isinstance(region, ee.geometry.Geometry):\n",
        "        image = image.clip(region)\n",
        "      elif isinstance(region, ee.featurecollection.FeatureCollection):\n",
        "        image = image.clipToCollection(region)\n",
        "    return image\n",
        "  else:\n",
        "    if region is not None:\n",
        "      if isinstance(region, ee.geometry.Geometry):\n",
        "        image = image.map(lambda img: img.clip(region))\n",
        "      elif isinstance(region, ee.featurecollection.FeatureCollection):\n",
        "        image = image.map(lambda img: img.clipToCollection(region))\n",
        "    return image\n"
      ],
      "metadata": {
        "id": "-thWRNHRn73v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Spectral indices/variables\n",
        "\n",
        "```\n",
        "satellite_list = [\n",
        "    'Landsat 7 SR',\n",
        "    'Landsat 8 SR',\n",
        "    'Landsat 9 SR',\n",
        "    'Landsat 7 TOA',\n",
        "    'Landsat 8 TOA',\n",
        "    'Landsat 9 TOA',\n",
        "    'Sentinel-2 SR',\n",
        "    'Sentinel-2 TOA']\n",
        "\n",
        "collections_list = [\n",
        "    'LANDSAT/LE07/C02/T1_L2',\n",
        "    'LANDSAT/LC08/C02/T1_L2',\n",
        "    'LANDSAT/LC09/C02/T1_L2',\n",
        "    'LANDSAT/LE07/C02/T1_TOA',\n",
        "    'LANDSAT/LC08/C02/T1_TOA',\n",
        "    'LANDSAT/LC09/C02/T1_TOA',\n",
        "    'COPERNICUS/S2_SR_HARMONIZED',\n",
        "    'COPERNICUS/S2_HARMONIZED']\n",
        "```"
      ],
      "metadata": {
        "id": "DVtS8SQSwzUQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "specialBandsNames = ['BLUE', 'GREEN', 'RED', 'NIR', 'SWIR']\n",
        "# ? SWIR1 or SWIR2\n",
        "specialBandsList = [\n",
        "    ['SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B7'],\n",
        "    ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B7'],\n",
        "    ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B7'],\n",
        "    ['B1', 'B2', 'B3', 'B4', 'B7'],\n",
        "    ['B2', 'B3', 'B4', 'B5', 'B7'],\n",
        "    ['B2', 'B3', 'B4', 'B5', 'B7'],\n",
        "    ['B2', 'B3', 'B4', 'B8', 'B12'],\n",
        "    ['B2', 'B3', 'B4', 'B8', 'B12']\n",
        "]\n",
        "\n",
        "specialBands = pd.DataFrame(np.array(specialBandsList),\n",
        "                            columns=specialBandsNames)\n",
        "\n",
        "def addSpectralIndices(image, ind, spectral_list):\n",
        "  \"\"\" Add variables to image bands, NDVI, NDWI, etc.\n",
        "\n",
        "  * Normalized Difference Vegetation Index\n",
        "  NDVI = (NIR-RED) / (NIR+RED)\n",
        "\n",
        "  * Normalized Difference Water Index\n",
        "  NDWI = (GREEN-NIR) / (GREEN+NIR)\n",
        "\n",
        "  * Normalized Burn Ratio\n",
        "  NBR = (NIR - SWIR) / (NIR + SWIR) using infrared,  short wave infrared\n",
        "\n",
        "  Args:\n",
        "    ind: index for the band list, corresponding to satellite selection\n",
        "  \"\"\"\n",
        "\n",
        "  if 'None' in spectral_list:\n",
        "    #print('No variables to be added.')\n",
        "    return image\n",
        "\n",
        "  #ind = collections_list.index(collection)\n",
        "  b = specialBands.iloc[ind, :]\n",
        "  #print('collection', collection, 'index', ind)\n",
        "  #print('special bands name', b)\n",
        "\n",
        "  #img_bands = image.bandNames().getInfo()\n",
        "  img_bands = ee.List(image.bandNames())\n",
        "  #print(img_bands)\n",
        "\n",
        "  for var in spectral_list:\n",
        "    if var == 'NDVI':\n",
        "      #if b['NIR'] not in img_bands or b['RED'] not in img_bands:\n",
        "      if img_bands.contains(b['NIR']) and img_bands.contains(b['RED']):\n",
        "        #print('adding ndvi:', b['NIR'], b['RED'])\n",
        "        ndvi = image.normalizedDifference([b['NIR'], b['RED']]).rename('NDVI')\n",
        "        image = image.addBands(ndvi)\n",
        "    if var == 'NDWI':\n",
        "      #if b['GREEN'] not in img_bands or b['NIR'] not in img_bands:\n",
        "      if img_bands.contains(b['GREEN']) and img_bands.contains(b['NIR']):\n",
        "        #print('adding ndwi:', b['GREEN'], b['NIR'])\n",
        "        ndwi = image.normalizedDifference([b['GREEN'], b['NIR']]).rename('NDWI')\n",
        "        image = image.addBands(ndwi)\n",
        "    if var == 'NBR':\n",
        "      #if b['NIR'] not in img_bands or b['SWIR'] not in img_bands:\n",
        "      if img_bands.contains(b['SWIR']) and img_bands.contains(b['NIR']):\n",
        "        #print('adding nbr:')\n",
        "        nbr = image.normalizedDifference([b['NIR'], b['SWIR']]).rename('NBR')\n",
        "        image = image.addBands(nbr)\n",
        "\n",
        "  return image\n",
        "\n",
        "def addVariables(image, var_list):\n",
        "  \"\"\"Add other variables as predictors: topo, climatic, etc.\"\"\"\n",
        "\n",
        "  if not var_list:\n",
        "    return image\n",
        "\n",
        "  elevation = ee.Image('USGS/SRTMGL1_003').select('elevation')\n",
        "  if region is not None:\n",
        "    if isinstance(region, ee.geometry.Geometry):\n",
        "      elevation = elevation.clip(region)\n",
        "    elif isinstance(region, ee.featurecollection.FeatureCollection):\n",
        "      elevation = elevation.clipToCollection(region)\n",
        "\n",
        "  slope = ee.Terrain.slope(elevation)\n",
        "\n",
        "  for var in var_list:\n",
        "    if var == 'Elevation':\n",
        "      image = image.addBands(elevation)\n",
        "    if var == 'Slope':\n",
        "      image = image.addBands(slope)\n",
        "\n",
        "  return image"
      ],
      "metadata": {
        "id": "EbLl6ALnVc45"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get image"
      ],
      "metadata": {
        "id": "abOCRerHeQB-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getImage():\n",
        "  \"\"\"\n",
        "  Read and check user input\n",
        "  Filter image collections\n",
        "  \"\"\"\n",
        "\n",
        "  global region, start_date, end_date\n",
        "  global feature_names, bands, spectral_list, var_list\n",
        "  global split_ratio, seed, scale\n",
        "\n",
        "  seed = 42 # hard-coded\n",
        "  # scale: pixel resultion for sampling\n",
        "\n",
        "  start_date = w_start_date.value.strftime(\"%Y-%m-%d\")\n",
        "  end_date = w_end_date.value.strftime(\"%Y-%m-%d\")\n",
        "  # to-do: not valid op\n",
        "  if end_date < start_date:\n",
        "    raise Exception(\"End_date < start_date.\")\n",
        "    return None\n",
        "\n",
        "  region = getRegion()\n",
        "\n",
        "  split_ratio = w_split_ratio.value\n",
        "\n",
        "  # multi-source\n",
        "  if w_multiSource.value == False:\n",
        "    collection = collections_list[satellite_list.index(w_satellite.value)]\n",
        "    bands = list(w_select_bands.value)\n",
        "    print('Collection:', collection)\n",
        "    #print('bands:', bands)\n",
        "  else:\n",
        "    print('Multi-source selected.')\n",
        "    #pprint({'multi-source': multiSource})\n",
        "\n",
        "  #print('region coordinates:', region.coordinates().getInfo())\n",
        "\n",
        "  # Spectral indices & ohter variables\n",
        "  spectral_list = list(w_spectral_indices.value)\n",
        "  var_list = list(w_variables.value)\n",
        "  #print('Spectral indices', var_list)\n",
        "\n",
        "  image = ee.Image()\n",
        "\n",
        "  # Multi-source satellites allowed\n",
        "  if w_multiSource.value == False or len(multiSource) == 1:\n",
        "    ind = satellite_list.index(w_satellite.value)\n",
        "    collection = collections_list[satellite_list.index(w_satellite.value)]\n",
        "    bands = list(w_select_bands.value)\n",
        "\n",
        "    image = filterImageCollection(collection, region, start_date, end_date, bands)\n",
        "    image = addSpectralIndices(image, ind, spectral_list)\n",
        "\n",
        "    # scale for sampleRegions()\n",
        "    if collection.startswith('LANDSAT'):\n",
        "      scale = 30\n",
        "    elif collection.startswith('COPERNICUS'):\n",
        "      scale = 10\n",
        "    else:\n",
        "      scale = 30\n",
        "\n",
        "  else:\n",
        "    \"\"\" Support multi-source classification\n",
        "    multiSource example\n",
        "    {\n",
        "      'Landsat 9 SR': ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6'],\n",
        "      'Sentinel-2 TOA': ['B2', 'B3', 'B4', 'B5', 'B6']\n",
        "    }\n",
        "    \"\"\"\n",
        "    scale_flag = 0\n",
        "    for sat, bands in multiSource.items():\n",
        "      ind = satellite_list.index(sat)\n",
        "      collection = collections_list[ind]\n",
        "\n",
        "      image0 = filterImageCollection(collection, region, start_date, end_date, bands)\n",
        "      image0 = addSpectralIndices(image0, ind, spectral_list)\n",
        "\n",
        "      # New band will be renamed with a numerical suffix, eg. `foo` -> `foo_1`\n",
        "      # Better to rename them with satellite prefix such as 'L8', 'S2'\n",
        "      image = image.addBands(image0)\n",
        "\n",
        "      # Determine scale, set to 10 as long as satellite include 'Sentinel-2'\n",
        "      # or collection includes 'COPERNICUS'\n",
        "      if collection.startswith('COPERNICUS'):\n",
        "        scale_flag = 1\n",
        "\n",
        "    if scale_flag == 1:\n",
        "      scale = 10\n",
        "    else:\n",
        "      scale = 30\n",
        "\n",
        "  # And other predictors such as topo, climatic variables\n",
        "  image = addVariables(image, var_list)\n",
        "\n",
        "  bands = image.bandNames().getInfo()\n",
        "  if 'constant' in bands:\n",
        "    bands.remove('constant')\n",
        "    image = image.select(bands)\n",
        "  feature_names = bands\n",
        "\n",
        "  print('Bands/feature names:', feature_names)\n",
        "\n",
        "  # image visualization parameter\n",
        "  vis_bands = ['B4', 'B3', 'B2']\n",
        "  if 'B4' not in bands:\n",
        "    vis_bands = ['SR_B4', 'SR_B3', 'SR_B2']\n",
        "\n",
        "  vis_params = {'min': 0, 'max': 0.3, 'bands': vis_bands}\n",
        "\n",
        "  # Check if vis_bands in bands, addLayer\n",
        "  # What about multi-source, not supported yet\n",
        "  vis_flag = all(b in bands for b in vis_bands)\n",
        "  if vis_flag:\n",
        "    Map.addLayer(image, vis_params, collection)\n",
        "    #Map.addLayer(image.select('NDVI'), vis_params, collection+ ' NDVI')\n",
        "\n",
        "    #w_map_output.clear_output()\n",
        "    with w_map_output:\n",
        "      text = 'Added image layers (natural color 432).'\n",
        "      htmlWidget = widgets.HTML(value=f\"<b><font color='red'>{text}</b>\")\n",
        "      display(htmlWidget)\n",
        "  if region is not None:\n",
        "    Map.centerObject(region, 12)\n",
        "\n",
        "  return image\n"
      ],
      "metadata": {
        "id": "u_B9JDlnWbRC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get temporal composites"
      ],
      "metadata": {
        "id": "UXATawtwfsRa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def addDates(img):\n",
        "  \"\"\"Add properties: date, month, year, or even doy and week \"\"\"\n",
        "  date = img.date()\n",
        "  date_str = date.format('YYYY-MM-dd')\n",
        "  month_str = date.format('YYYY-MM')\n",
        "  return img.set('date', date_str) \\\n",
        "            .set('month', month_str) \\\n",
        "            .set('year', date.get('year'))\n",
        "\n",
        "def temporalComposite(dataset, interval):\n",
        "  \"\"\"create temporal composite for classifications\n",
        "  by one of GEE join: date_match, month_match, year_match\n",
        "\n",
        "  date_match is also used to get sample features if there is a 'date' property\n",
        "  associated with labeled points\n",
        "  \"\"\"\n",
        "\n",
        "  temporal_match = interval + '_match'\n",
        "\n",
        "  distinctDates = dataset.distinct(interval).sort(interval)\n",
        "  filter = ee.Filter.equals(leftField=interval, rightField=interval)\n",
        "  join = ee.Join.saveAll(temporal_match)\n",
        "  joinCol = join.apply(distinctDates, dataset, filter)\n",
        "\n",
        "  def mapJoinCollection(img):\n",
        "    tmp = ee.ImageCollection.fromImages(img.get(temporal_match))\n",
        "\n",
        "    if temporal_interval == 'date':\n",
        "      tmp = tmp.mosaic()\n",
        "    else:\n",
        "      tmp = tmp.median()\n",
        "\n",
        "    return tmp.copyProperties(img, ['date', 'month', 'year', 'system:time_start'])\n",
        "\n",
        "  colMosaic = joinCol.map(mapJoinCollection)\n",
        "\n",
        "  return colMosaic\n",
        "\n",
        "def getRawImageCollections():\n",
        "  \"\"\"Get raw image collection, which is later used to create temporal compoiste\n",
        "\n",
        "  Does not yet support multi-source\n",
        "  \"\"\"\n",
        "  # dataset = getRawImageCollections()\n",
        "  if w_multiSource.value == False or len(multiSource) == 1:\n",
        "    ind = satellite_list.index(w_satellite.value)\n",
        "    collection = collections_list[satellite_list.index(w_satellite.value)]\n",
        "    bands = list(w_select_bands.value)\n",
        "\n",
        "    dataset = filterImageCollection(collection, region, start_date, end_date, bands,\n",
        "                                    return_type='ic')\n",
        "    dataset = dataset.map(addDates)\n",
        "\n",
        "    dataset = dataset.map(lambda img: addSpectralIndices(img, ind, spectral_list))\n",
        "    dataset = dataset.map(lambda img: addVariables(img, var_list))\n",
        "\n",
        "    return dataset\n",
        "  else:\n",
        "    raise Exception(\"No support yet for multi-source composite for spatiotemporal dynamics.\")\n"
      ],
      "metadata": {
        "id": "dgXMZuLNfrb5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sample collections by feature dates"
      ],
      "metadata": {
        "id": "_-lqN9pYa591"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sampleRegionsByDates(colMosaic_date):\n",
        "  \"\"\"Sample temporal composite for predictor variables, according to dated\n",
        "   feature collections\n",
        "  \"\"\"\n",
        "\n",
        "  #to-do: a difference of 2 days may be acceptable between image dates\n",
        "  #       and sample collection dates\n",
        "  filter0 = ee.Filter.equals(leftField='date', rightField='date')\n",
        "  join0 = ee.Join.saveAll('date_match')\n",
        "\n",
        "  joinCol_0 = join0.apply(LABEL_DATA.distinct('date').sort('date'),\n",
        "                          colMosaic_date,\n",
        "                          filter0)\n",
        "\n",
        "  def mapSampleRegions(feat):\n",
        "    \"\"\"Sample each image whose date corresponds to the field samples \"\"\"\n",
        "\n",
        "    image = ee.Image(ee.List(feat.get('date_match')).get(0))\n",
        "    fc1 = LABEL_DATA.filter(ee.Filter.eq('date', feat.get('date')))\n",
        "\n",
        "    samples1 = image.sampleRegions(\n",
        "        collection=fc1, properties=[LABEL],\n",
        "        tileScale=4,\n",
        "        scale=scale, geometries=True)\n",
        "\n",
        "    return samples1\n",
        "\n",
        "  print('Sample temporal composite according to dated feature collections ...')\n",
        "  samples = joinCol_0.map(mapSampleRegions).flatten()\n",
        "\n",
        "  return samples\n",
        "\n",
        "# test function\n",
        "if 0:\n",
        "  samples = sampleRegionsByDates(colMosaic_date)\n",
        "\n",
        "  samples.limit(5)\n",
        "  #samples.aggregate_histogram(LABEL)"
      ],
      "metadata": {
        "id": "gJSLZMkgf20R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getTemporalCompSamples(interval):\n",
        "  \"\"\"Get temporal composite by specified interval, and samples\n",
        "\n",
        "  Does not yet support multi-source\n",
        "  \"\"\"\n",
        "  global colMosaic_date, colMosaic_tmp\n",
        "\n",
        "  dataset = getRawImageCollections()\n",
        "\n",
        "  # only if interval not 'all-time'\n",
        "  colMosaic_date = temporalComposite(dataset, 'date')\n",
        "  samples = sampleRegionsByDates(colMosaic_date)\n",
        "\n",
        "  if interval == 'date':\n",
        "    colMosaic_tmp = colMosaic_date\n",
        "  elif interval == 'all-time':\n",
        "    colMosaic_tmp = None\n",
        "    print(\"No temporal composite for all-time interval.\")\n",
        "    #raise Exception(\"No temporal composite for all-time interval.\")\n",
        "  else:\n",
        "    colMosaic_tmp = temporalComposite(dataset, interval)\n",
        "\n",
        "  return samples"
      ],
      "metadata": {
        "id": "KXfqzlyEB7Mb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get samples data"
      ],
      "metadata": {
        "id": "nz0XcQd7_CHV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getSamplesData(imageM):\n",
        "  \"\"\" Get sample data/predictor variables from one of the two options\n",
        "  ['Upload samples', 'Sample LULC products']\n",
        "\n",
        "  In case the 1st option not called when customizing class colors not enabled,\n",
        "  call specifically here to define some label-related globals\n",
        "\n",
        "  def fcLabelStyle(feature):\n",
        "    return feature.set('style',\n",
        "      {'color': ee.List(CLASS_PALETTE).get(feature.get(LABEL))}\n",
        "    )\n",
        "  \"\"\"\n",
        "\n",
        "  global CLASS_NAMES, LABEL_DATA, CLASS_PALETTE, temporal_interval\n",
        "  global training, testing\n",
        "  global colMosaic_date, colMosaic_tmp\n",
        "\n",
        "  if w_sample_select.value == 'Upload samples':\n",
        "    CLASS_NAMES, LABEL_DATA = getClassLabelsFromFile()\n",
        "    CLASS_PALETTE = [c.value for c in w_palette.children]\n",
        "    print('Labels read from file.')\n",
        "\n",
        "  elif w_sample_select.value == 'Sample LULC products':\n",
        "    LABEL_DATA, CLASS_PALETTE = getClassLabelsFromLC()\n",
        "    print('No date assigned to LABEL_DATA.')\n",
        "\n",
        "  # Style feature collections (sample points)\n",
        "  # Differentiate training from testing samples by using different markers\n",
        "  def fcLabelStyle(feature):\n",
        "    shapes = ['circle', 'triangle']\n",
        "    # Set point shape to triangle for testing labels\n",
        "    return feature.set('style', {\n",
        "        'color': ee.List(CLASS_PALETTE).get(feature.get(LABEL)),\n",
        "        'pointShape': ee.List(shapes).get(ee.Number(feature.get('random')).gte(split_ratio))\n",
        "        }\n",
        "    )\n",
        "\n",
        "  #label_styled = LABEL_DATA.select(LABEL).map(fcLabelStyle)\n",
        "  #Map.addLayer(label_styled.style(styleProperty='style'), {}, 'Label points')\n",
        "\n",
        "  if w_temporal.value == 'All dates':\n",
        "    temporal_interval = 'all-time'\n",
        "    print(\"No temporal composite for all-time interval, except for sampling with dated features.\")\n",
        "    #colMosaic_tmp = None\n",
        "  elif w_temporal.value == 'Yearly':\n",
        "    temporal_interval = 'year'\n",
        "  elif w_temporal.value == 'Monthly':\n",
        "    temporal_interval = 'month'\n",
        "  elif w_temporal.value == 'Daily':\n",
        "    temporal_interval = 'date'\n",
        "\n",
        "  if (temporal_interval != 'all-time' or\n",
        "      'date' in LABEL_DATA.first().propertyNames().getInfo()):\n",
        "    dataset = getRawImageCollections()\n",
        "    #colMosaic_date = temporalComposite(dataset, 'date')\n",
        "    if temporal_interval != 'all-time':\n",
        "      colMosaic_tmp = temporalComposite(dataset, temporal_interval)\n",
        "\n",
        "  print(f'Sample regions for predictor variables, scale={scale} ...')\n",
        "\n",
        "  if 'date' not in LABEL_DATA.first().propertyNames().getInfo():\n",
        "    #or temporal_interval == 'all-time'\n",
        "    # Sample the median image at the labeled points\n",
        "    samples = imageM.sampleRegions(\n",
        "        collection=LABEL_DATA,\n",
        "        properties=[LABEL],\n",
        "        scale=scale,\n",
        "        tileScale=4,\n",
        "        geometries=True)\n",
        "  else:\n",
        "    # Get samples from dated features\n",
        "    #print('call getTemporalCompSamples in getSamplesData()')\n",
        "    if temporal_interval == 'date':\n",
        "      colMosaic_date = colMosaic_tmp\n",
        "    else:\n",
        "      colMosaic_date = temporalComposite(dataset, 'date')\n",
        "    samples = sampleRegionsByDates(colMosaic_date)\n",
        "    #samples = getTemporalCompSamples(temporal_interval)\n",
        "\n",
        "  samples = samples.randomColumn()\n",
        "\n",
        "  # Partition the sample approximately 70-30.\n",
        "  training = samples.filter(ee.Filter.lt('random', split_ratio))\n",
        "  testing = samples.filter(ee.Filter.gte('random', split_ratio))\n",
        "\n",
        "  # Print the first couple points to verify.\n",
        "  #pprint({'training': training.first().getInfo()})\n",
        "  #pprint({'testing': testing.first().getInfo()})\n",
        "\n",
        "  train_styled = training.select([LABEL, 'random']).map(fcLabelStyle)\n",
        "  test_styled = testing.select([LABEL, 'random']).map(fcLabelStyle)\n",
        "\n",
        "  Map.centerObject(region, 10)\n",
        "  Map.addLayer(train_styled.style(styleProperty='style'), {}, 'Train labels')\n",
        "  Map.addLayer(test_styled.style(styleProperty='style'), {}, 'Test labels')\n",
        "\n",
        "  w_map_output.clear_output()\n",
        "  with w_map_output:\n",
        "    text = 'Added labels layers (Train + Test).'\n",
        "    htmlWidget = widgets.HTML(value=f\"<b><font color='red'>{text}</b>\")\n",
        "    display(htmlWidget)\n",
        "\n",
        "  #return training, testing"
      ],
      "metadata": {
        "id": "9PXU-loXMybE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### GEE classifier"
      ],
      "metadata": {
        "id": "mawT0YMu1Z_j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def runGeeClassifier(imageM):\n",
        "  \"\"\" Train GEE classifier and classify the image \"\"\"\n",
        "\n",
        "  global classifier, classifier_param_dict, image_classified, resultVis\n",
        "\n",
        "  print('Train GEE classifier ...')\n",
        "\n",
        "  classifier_select = w_classifier_select.value\n",
        "\n",
        "  # If users customize classifier parameters: random forest, cart\n",
        "  if w_classifier_customize.value:\n",
        "    classifier_param_dict = {w.description: w.value\n",
        "                             for w in w_classifier_param.children}\n",
        "    print('Using customized parameters:', classifier_select)\n",
        "    #pprint(classifier_param_dict)\n",
        "\n",
        "    if classifier_select == 'RandomForest':\n",
        "      # GEE random forest classifer\n",
        "      classifier = ee.Classifier.smileRandomForest(\n",
        "          **classifier_param_dict,\n",
        "          seed = seed\n",
        "      )\n",
        "    elif classifier_select == 'CART':\n",
        "      classifier = ee.Classifier.smileCart(**classifier_param_dict)\n",
        "\n",
        "  else:\n",
        "    print('Using default parameters:', classifier_select)\n",
        "\n",
        "    if classifier_select == 'RandomForest':\n",
        "      # GEE random forest classifer\n",
        "      classifier = ee.Classifier.smileRandomForest(100)\n",
        "    elif classifier_select == 'CART':\n",
        "      # Train a CART classifier with default parameters.\n",
        "      classifier = ee.Classifier.smileCart()\n",
        "\n",
        "  # Train the classifier\n",
        "  classifier = classifier.train(training, LABEL, bands)\n",
        "\n",
        "  print('Classify the image ...')\n",
        "  # Classify the image with the same bands used for training.\n",
        "  # result image consists of one band 'classification' only\n",
        "\n",
        "  if temporal_interval == 'all-time':\n",
        "    image_classified = imageM.select(feature_names).classify(classifier)\n",
        "  else:\n",
        "    image_classified = ee.ImageCollection(colMosaic_tmp).median() \\\n",
        "                        .select(feature_names).classify(classifier)\n",
        "\n",
        "  # Display the clusters with random colors.\n",
        "  #Map.addLayer(result.randomVisualizer(), {}, 'classified random')\n",
        "\n",
        "  # Class names: Urban, Vegetation, Water\n",
        "  resultVis = {'min': 0, 'max': len(CLASS_NAMES)-1, 'palette': CLASS_PALETTE}\n",
        "  Map.addLayer(image_classified, resultVis, 'Classified (median)')\n",
        "\n",
        "  # Remove the legend if already exists\n",
        "  Map.remove_legends()\n",
        "\n",
        "  Map.add_legend(\n",
        "      labels=CLASS_NAMES, colors=CLASS_PALETTE,\n",
        "      title='Legend', layer_name='Classified', position='bottomright'\n",
        "  )\n",
        "\n",
        "  with w_map_output:\n",
        "    w_map_output.clear_output()\n",
        "    text = 'Added classified image with legend.'\n",
        "    htmlWidget = widgets.HTML(value = f\"<b><font color='red'>{text}</b>\")\n",
        "    display(htmlWidget)\n",
        "\n",
        "  #return training, testing, classifier, image_classified\n"
      ],
      "metadata": {
        "id": "nTSFrv0inbxD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sklearn classifer & metrics\n"
      ],
      "metadata": {
        "id": "uXO4Lt95m-yd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, accuracy_score, \\\n",
        "                            confusion_matrix, ConfusionMatrixDisplay\n",
        "\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.inspection import permutation_importance\n",
        "\n",
        "def classifierMetrics(y_test, y_pred):\n",
        "  \"\"\"print classification report, accuracy_score, and confusion matrix\n",
        "  \"\"\"\n",
        "  labels = list(range(0, len(CLASS_NAMES)))\n",
        "  print('\\nClassification report:\\n',\n",
        "        classification_report(y_test, y_pred, labels=labels, target_names=CLASS_NAMES))\n",
        "  print('Accuracy score: {:.2f}'.format(accuracy_score(y_test, y_pred)))\n",
        "\n",
        "  cm = confusion_matrix(y_test, y_pred, labels=labels)\n",
        "  print('\\nConfusion matrix:\\n', cm)\n",
        "  print('\\n')\n",
        "\n",
        "def sklearnClassifier(training, testing):\n",
        "  \"\"\" Generate train/test data for and train the sk-classifier \"\"\"\n",
        "\n",
        "  global classifier_param_dict, X_train, y_train\n",
        "\n",
        "  # limit to 5000 elements\n",
        "  # could use a for loop to get all the sample data\n",
        "  train_size = training.size().getInfo()\n",
        "  if train_size >= 5000:\n",
        "    print('Training data size too big for one-time query. Limit to the first 5000 elements.')\n",
        "    nqueries = int(train_size/5000) + 1\n",
        "    print('Could use a for loop to get all the samples of size', train_size )\n",
        "    training = training.limit(5000)\n",
        "\n",
        "  train_data = geemap.ee_to_df(training)\n",
        "  test_data = geemap.ee_to_df(testing)\n",
        "\n",
        "  X_train = train_data[feature_names]\n",
        "  y_train = train_data[LABEL]\n",
        "\n",
        "  X_test = test_data[feature_names]\n",
        "  y_test = test_data[LABEL]\n",
        "\n",
        "  #X_train, X_test, y_train, y_test\n",
        "  #print('X_test\\n', X_test[:5])\n",
        "  #print('y_test\\n', y_test[:5])\n",
        "\n",
        "  # Sychronize classifier parameters with GEE's smileRF\n",
        "  if not w_classifier_customize.value:\n",
        "    classifier_param_dict = {'numberOfTrees': 100,\n",
        "                             'minLeafPopulation': 1}\n",
        "\n",
        "  forest = RandomForestClassifier(\n",
        "      n_estimators=classifier_param_dict['numberOfTrees'],\n",
        "      criterion='gini',\n",
        "      max_depth=None,\n",
        "      min_samples_split=2,\n",
        "      min_samples_leaf=classifier_param_dict['minLeafPopulation'],\n",
        "      min_weight_fraction_leaf=0.0,\n",
        "      max_features='sqrt',\n",
        "      max_leaf_nodes=None,\n",
        "      min_impurity_decrease=0.0,\n",
        "      bootstrap=True,\n",
        "      oob_score=False,\n",
        "      n_jobs=None,\n",
        "      random_state=seed,\n",
        "  )\n",
        "\n",
        "  forest.fit(X_train, y_train)\n",
        "\n",
        "  #print(f\"RF train accuracy: {forest.score(X_train, y_train):.3f}\")\n",
        "  #print(f\"RF test accuracy: {forest.score(X_test, y_test):.3f}\")\n",
        "\n",
        "  return forest, X_test, y_test"
      ],
      "metadata": {
        "id": "jq1PTaxtjiIp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Zonal statistics"
      ],
      "metadata": {
        "id": "4YwJUyvv3KOa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def zonalStatistics(classified, roi=None, return_type='dict'):\n",
        "  \"\"\"Calculate zonal areas for each class, given classified image\n",
        "\n",
        "  Args:\n",
        "    classified: classified image with band 'classification'\n",
        "    return_type: 'dict' or 'feature', returns a dict or ee.Feature\n",
        "  \"\"\"\n",
        "\n",
        "  if roi == None:\n",
        "    roi = region\n",
        "\n",
        "  # Calculate areas (km^2) for each class\n",
        "  areaImage = ee.Image.pixelArea().divide(1e6).addBands(classified)\n",
        "\n",
        "  areas = areaImage.reduceRegion(\n",
        "              **{\n",
        "                  \"reducer\": ee.Reducer.sum().group(\n",
        "                      **{\n",
        "                          \"groupField\": 1,\n",
        "                          \"groupName\": \"classification\",\n",
        "                      }\n",
        "                  ),\n",
        "                  \"geometry\": roi, #classified.geometry(),\n",
        "                  \"scale\": 100,\n",
        "                  \"maxPixels\": 1e9,\n",
        "                  \"bestEffort\": True,\n",
        "                  \"tileScale\": 4\n",
        "              }\n",
        "  )\n",
        "\n",
        "  if return_type == 'dict':\n",
        "    area_list = areas.getInfo().get('groups')\n",
        "    #print(area_list) # which is a list of dict with keys 'classification' and 'sum'\n",
        "\n",
        "    # keys/labels are integer numbers\n",
        "    area_labels = [d['classification'] for d in area_list]\n",
        "    area_values = [d['sum'] for d in area_list]\n",
        "\n",
        "    zonal_dict = {label:area for label, area in zip(area_labels, area_values)}\n",
        "\n",
        "    return zonal_dict\n",
        "\n",
        "  elif return_type == 'feature':\n",
        "    area_list = ee.List(areas.get('groups'))\n",
        "    keys_list = area_list.map(lambda x: ee.Number(\n",
        "        ee.Dictionary(x).get('classification')\n",
        "        ).format()\n",
        "    )\n",
        "    values_list = area_list.map(lambda x: ee.Dictionary(x).get('sum'))\n",
        "\n",
        "    dict0 = ee.Dictionary.fromLists(keys_list, values_list)\n",
        "\n",
        "    return ee.Feature(None, dict0)"
      ],
      "metadata": {
        "id": "_key6dRhxpXd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classify image collections\n",
        "\n",
        "```\n",
        "if 1:\n",
        "  # either\n",
        "  colMosaic_tmp_classified = getClassifiedCollections()\n",
        "  df_tmpZonal = getClassifiedZonalAreas(classify=False)\n",
        "else:\n",
        "  # or\n",
        "  df_tmpZonal = getClassifiedZonalAreas()\n",
        "\n",
        "_ = interact(\n",
        "  plotTemporalZonal,\n",
        "  rot=w_rotation,\n",
        "  select=w_zonal_selectClasses,\n",
        "  chartType=w_zonal_chartType,\n",
        "  subplot=w_zonal_subplot,\n",
        "  df=fixed(df_tmpZonal)\n",
        ")\n",
        "```"
      ],
      "metadata": {
        "id": "aqFG7zhoGEpV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getClassifiedCollections():\n",
        "  \"\"\"Classify the temporal composite and calculate zonal areas\n",
        "\n",
        "  Return classified image collection\n",
        "  \"\"\"\n",
        "  global colMosaic_tmp_classified, listOfImages, col_dates_list\n",
        "\n",
        "  def mapClassifyCollections(image):\n",
        "      return ee.Image(image).select(bands).classify(classifier) \\\n",
        "              .copyProperties(image, [temporal_interval])\n",
        "\n",
        "  #colMosaic_tmp = temporalCollection(rawDataset, temporal_interval)\n",
        "\n",
        "  print('Classifying temporal composite ...')\n",
        "  if colMosaic_tmp == None:\n",
        "    raise Exception(\"Temporal composite None for all-time interval.\")\n",
        "\n",
        "  colMosaic_tmp_classified = colMosaic_tmp.map(mapClassifyCollections)\n",
        "  w_classified_tmpflag.value = True\n",
        "  listOfImages = colMosaic_tmp_classified.toList(colMosaic_tmp_classified.size())\n",
        "\n",
        "  col_dates = colMosaic_tmp.aggregate_array(temporal_interval).distinct().sort()\n",
        "  col_dates_list = col_dates.getInfo()\n",
        "\n",
        "  return colMosaic_tmp_classified\n",
        "\n",
        "def getClassifiedZonalAreas(roi=None, classify=True):\n",
        "  \"\"\"Calculate zonal areas for the classified collection\n",
        "\n",
        "  Args\n",
        "  roi: region of interest, default to the entire region\n",
        "       could be a subarea recognized as a hotspot area\n",
        "  classify: flag to classify the image collection\n",
        "\n",
        "  Return zonal feature collection\n",
        "  \"\"\"\n",
        "  global colMosaic_tmp_classified, df_tmpZonal\n",
        "\n",
        "  if roi == None:\n",
        "    roi = region\n",
        "\n",
        "  if classify:\n",
        "    colMosaic_tmp_classified = getClassifiedCollections()\n",
        "\n",
        "  print('Calculating zonal areas for the classified composite ...')\n",
        "  colMosaic_tmp_zonal = colMosaic_tmp_classified.map(\n",
        "      lambda classified: zonalStatistics(classified, roi, 'feature'))\n",
        "\n",
        "  df = geemap.ee_to_df(colMosaic_tmp_zonal)\n",
        "\n",
        "  # sample_dates = LABEL_DATA.aggregate_array('date').distinct()\n",
        "  col_dates = colMosaic_tmp.aggregate_array(temporal_interval).distinct().sort()\n",
        "  col_dates_list = col_dates.getInfo()\n",
        "\n",
        "  if temporal_interval == 'year':\n",
        "    fmt = '%Y'\n",
        "  elif temporal_interval == 'month':\n",
        "    fmt = '%Y-%m'\n",
        "  else:\n",
        "    fmt = '%Y-%m-%d'\n",
        "  df.index = pd.to_datetime(col_dates_list, format=fmt)\n",
        "\n",
        "  if len(df.columns) == len(CLASS_NAMES):\n",
        "    df.columns = CLASS_NAMES\n",
        "  else:\n",
        "    df.columns = [CLASS_NAMES[int(c)] for c in df.columns]\n",
        "\n",
        "  df_tmpZonal = df\n",
        "\n",
        "  return df_tmpZonal\n",
        "\n",
        "if 0:\n",
        "\n",
        "  if 1:\n",
        "    # either\n",
        "    colMosaic_tmp_classified = getClassifiedCollections()\n",
        "    df_tmpZonal = getClassifiedZonalAreas(classify=False)\n",
        "  else:\n",
        "    # or\n",
        "    df_tmpZonal = getClassifiedZonalAreas()"
      ],
      "metadata": {
        "id": "ouooNOCqhLwI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Colab tabs\n",
        "\n",
        "* Labels histogram\n",
        "* Parallel coordinate plot\n",
        "* Classifier assessment\n",
        "* Feature importance\n",
        "* Shap values\n",
        "* Zonal statistics\n",
        "* Spatio-temporal dynamics"
      ],
      "metadata": {
        "id": "D_CLm9w_QXUu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Widgets for interactive plot"
      ],
      "metadata": {
        "id": "8vOW1NhviMLV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# widgets error: some global variables not defined\n",
        "\n",
        "#if w_classified_flag.value:\n",
        "    # define widgets here\n"
      ],
      "metadata": {
        "id": "oVi0WPwriOnh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Plot functions"
      ],
      "metadata": {
        "id": "c1h4msoCXVYM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.inspection import permutation_importance\n",
        "import shap\n",
        "from ipywidgets import interact, interactive, interactive_output, fixed\n",
        "from google.colab import widgets as cwidgets\n",
        "import seaborn as sns\n",
        "import plotly.express as px\n",
        "\n",
        "def plotLabelsHist(width, rot, label_hist):\n",
        "  x = [CLASS_NAMES[int(k)] for k in label_hist.keys()]\n",
        "  y = list(label_hist.values())\n",
        "  pal = [CLASS_PALETTE[int(k)] for k in label_hist.keys()]\n",
        "\n",
        "  fig1, ax1 = plt.subplots()\n",
        "  sns.barplot(x=x, y=y, ax=ax1, palette=pal)\n",
        "  plt.xticks(rotation=rot)\n",
        "  ax1.set_ylabel('Counts')\n",
        "  change_barplot_width(ax1, width)\n",
        "  ax1.set_title('Labels class distribution')\n",
        "  plt.show()\n",
        "\n",
        "def plotZonalAreas(width, rot, zonal_dict):\n",
        "  #zonal_dict = zonalStatistics(image_classified)\n",
        "  #print(zonal_dict)\n",
        "\n",
        "  fig, ax2 = plt.subplots()\n",
        "  x = [CLASS_NAMES[i] for i in zonal_dict.keys()]\n",
        "  pal = [CLASS_PALETTE[i] for i in zonal_dict.keys()]\n",
        "  area_values = list(zonal_dict.values())\n",
        "\n",
        "  sns.barplot(x=x, y=area_values, ax=ax2, palette=pal)\n",
        "  plt.xticks(rotation=rot)\n",
        "  change_barplot_width(ax2, width)\n",
        "  ax2.set_ylabel('$Areas\\ (km^{2})$')\n",
        "  ax2.set_title('Class area distribution for predicted image')\n",
        "  plt.show()\n",
        "\n",
        "  # Tabulate the zonal areas and the percentage\n",
        "  zonalAreas = pd.DataFrame({'Areas (km^2)': area_values}, index=x)\n",
        "  zonalAreas['Percentage (%)'] = zonalAreas['Areas (km^2)']/sum(area_values)*100\n",
        "  zonalAreas.loc[\"Sum of classes\"] = zonalAreas.sum()\n",
        "  print('\\n', zonalAreas, '\\n')\n",
        "\n",
        "def plotConfusionMatrix(normalize, gee_ytest, gee_ypred, y_test, y_pred):\n",
        "  fig, (ax1, ax2) = plt.subplots(1,2, figsize=(14,6))\n",
        "  labels = list(range(0, len(CLASS_NAMES)))\n",
        "  if normalize == '-':\n",
        "    normalize = None\n",
        "  cm1 = confusion_matrix(gee_ytest, gee_ypred, labels=labels, normalize=normalize)\n",
        "  cm2 = confusion_matrix(y_test, y_pred, labels=labels, normalize=normalize)\n",
        "\n",
        "  sns.heatmap(cm1, annot=True, ax=ax1, cmap='Blues',\n",
        "              xticklabels=CLASS_NAMES, yticklabels=CLASS_NAMES)\n",
        "  ax1.set(xlabel=\"Predicted\", ylabel=\"True\", title='GEE')\n",
        "\n",
        "  # cmap='Blues' or \"OrRd\"\n",
        "  sns.heatmap(cm2, annot=True, ax=ax2, cmap='Blues',\n",
        "              xticklabels=CLASS_NAMES, yticklabels=CLASS_NAMES)\n",
        "  ax2.set(xlabel=\"Predicted\", ylabel=\"True\", title='sklearn')\n",
        "  plt.show()\n"
      ],
      "metadata": {
        "id": "yWiFypGFQgu2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plotTemporalZonal(rot, select, chartType, subplot, df):\n",
        "\n",
        "  to_plot = [CLASS_NAMES.index(c) for c in select]\n",
        "  colors = [CLASS_PALETTE[i] for i in to_plot]\n",
        "  figsize = (11, 6)\n",
        "\n",
        "  if chartType == 'line':\n",
        "    if not subplot or ( subplot and len(to_plot)==1 ):\n",
        "      fig, ax = plt.subplots(figsize=figsize)\n",
        "      df.iloc[:, to_plot].plot(ax=ax, color=colors)\n",
        "      ax.set_ylabel('$Areas\\ (km^{2})$')\n",
        "    else:\n",
        "      fig, ax = plt.subplots(len(to_plot), 1, figsize=figsize)\n",
        "      for ind, col in enumerate(to_plot):\n",
        "        df.iloc[:, [col]].plot(ax=ax[ind], color=CLASS_PALETTE[col])\n",
        "        ax[ind].set_ylabel('$Areas\\ (km^{2})$')\n",
        "        if ind < len(to_plot)-1:\n",
        "          ax[ind].set_xticklabels('')\n",
        "          ax[ind].set_xticklabels('', minor=True)\n",
        "    fig.autofmt_xdate(rotation=rot, ha='center')\n",
        "    plt.show()\n",
        "  elif chartType == 'bar':\n",
        "    # pandas bar plot processes the date variable as a categorical variable where\n",
        "    # each date is considered to be a unique category,\n",
        "    # https://stackoverflow.com/questions/30133280/pandas-bar-plot-changes-date-format\n",
        "    if temporal_interval == 'year':\n",
        "      tick_labels = [x.strftime(\"%Y\") for x in df.index]\n",
        "    else:\n",
        "      tick_labels = [x.strftime(\"%m\\n%Y\") if x.month==1 else x.strftime('%m') for x in df.index]\n",
        "      tick_labels = [tick.lstrip(\"0\") for tick in tick_labels]\n",
        "    if 0:\n",
        "      tick_labels[1::3] = [''] * len(tick_labels[1::3])\n",
        "      tick_labels[2::3] = [''] * len(tick_labels[2::3])\n",
        "\n",
        "    nplots = len(to_plot)\n",
        "\n",
        "    if subplot and len(to_plot)>1:\n",
        "      ax = df.iloc[:, to_plot].plot.bar(figsize=figsize, subplots=True,\n",
        "                                        color=colors, rot=rot)\n",
        "\n",
        "      for i in range(nplots):\n",
        "        ax[i].set_title('')\n",
        "        ax[i].set_ylabel('$Areas\\ (km^{2})$')\n",
        "\n",
        "      ax[nplots-1].set_xticklabels(tick_labels)\n",
        "    else:\n",
        "      fig, ax = plt.subplots(figsize=figsize)\n",
        "      df.iloc[:, to_plot].plot.bar(ax=ax, color=colors, rot=rot)\n",
        "      ax.set_xticklabels(tick_labels)\n",
        "      ax.set_ylabel('$Areas\\ (km^{2})$')\n",
        "    plt.show()\n"
      ],
      "metadata": {
        "id": "ol_Ujwcwi29E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plotClassifiedGrid(select_dates, grid_column, figsize, dim):\n",
        "  '''Plot image thumbnails in a grid for selected dates\n",
        "  First export the thumbnail, then imshow\n",
        "  '''\n",
        "  #rows, cols = [int(f) for f in grid_size.split(',')]\n",
        "  cols = grid_column\n",
        "\n",
        "  img_count = len(select_dates)\n",
        "  rows = int(np.ceil(img_count/cols))\n",
        "\n",
        "  figsize = [int(f) for f in figsize.split(',')]\n",
        "\n",
        "  print(img_count, 'dates selected')\n",
        "\n",
        "  col_index = [col_dates_list.index(d) for d in select_dates]\n",
        "  #print(col_index)\n",
        "\n",
        "  resultVis1 = {'min': 0, 'max': len(CLASS_NAMES)-1, 'palette': CLASS_PALETTE}\n",
        "  if isinstance(region, ee.featurecollection.FeatureCollection):\n",
        "    roi = region.geometry()\n",
        "  else:\n",
        "    roi = region\n",
        "\n",
        "  imgs = []\n",
        "  for s in col_index:\n",
        "    out_img = 'tmp_thumbnail_{}.png'.format(col_dates_list[s])\n",
        "\n",
        "    if os.path.isfile(out_img):\n",
        "      print('Found existing ', out_img)\n",
        "      imgs.append(plt.imread(out_img))\n",
        "    else:\n",
        "      print('Exporting {} ...'.format(out_img))\n",
        "      result = ee.Image(listOfImages.get(s))\n",
        "\n",
        "      geemap.get_image_thumbnail(result, out_img, resultVis1, dimensions=dim, region=roi)\n",
        "      imgs.append(plt.imread(out_img))\n",
        "    #geemap.show_image(out_img)\n",
        "  print('\\n')\n",
        "\n",
        "  fig, axes = plt.subplots(\n",
        "      nrows=rows,\n",
        "      ncols=cols,\n",
        "      figsize=figsize\n",
        "  )\n",
        "\n",
        "  for i, ax in enumerate(axes.flat):\n",
        "    if i >= img_count:\n",
        "      ax.set_axis_off()\n",
        "      continue\n",
        "    ax.imshow(imgs[i])\n",
        "    ax.axis('off')\n",
        "    ax.set_xlabel(i)\n",
        "    ax.set_title(col_dates_list[col_index[i]])\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "bSbi3GpoA0_s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# some barplot utility functions\n",
        "def change_barplot_width(ax, new_value):\n",
        "  for patch in ax.patches :\n",
        "    current_width = patch.get_width()\n",
        "    diff = current_width - new_value\n",
        "\n",
        "    # we change the bar width\n",
        "    patch.set_width(new_value)\n",
        "\n",
        "    # we recenter the bar\n",
        "    patch.set_x(patch.get_x() + diff * .5)\n",
        "\n",
        "def change_barhplot_width(ax, new_value):\n",
        "  for patch in ax.patches :\n",
        "    current_height = patch.get_height()\n",
        "    diff = current_height - new_value\n",
        "\n",
        "    # we change the bar width\n",
        "    patch.set_height(new_value)\n",
        "\n",
        "    # we recenter the bar\n",
        "    patch.set_y(patch.get_y() + diff * .5)"
      ],
      "metadata": {
        "id": "Ju0iBezgCWpH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Feature importance function\n",
        "\n",
        "Not just feature importance, actually."
      ],
      "metadata": {
        "id": "LDFQou27jcKu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def createTabs():\n",
        "  \"\"\"\n",
        "  Train/predict sklearn classifer\n",
        "  Show Classifier metrics\n",
        "  Show feature importance/shap values plot\n",
        "  Claculate and show zonal areas\n",
        "    classifier: gee smilerf classifer\n",
        "    forest: sklearn rf classifier\n",
        "  \"\"\"\n",
        "\n",
        "  global forest, shap_values, X_test, y_test\n",
        "\n",
        "  if not w_classified_flag.value:\n",
        "    print('Classify the image first.')\n",
        "    return\n",
        "  if w_classifier_select.value != 'RandomForest':\n",
        "    print('Select RandomForest to display feature importance.')\n",
        "    return\n",
        "\n",
        "  # GEE classify test data, to calculate some classifier metrics\n",
        "  test_classified = testing.classify(classifier)\n",
        "\n",
        "  gee_result = geemap.ee_to_df(test_classified.select([LABEL, 'classification']))\n",
        "\n",
        "  gee_ytest = gee_result[LABEL]\n",
        "  gee_ypred = gee_result['classification']\n",
        "\n",
        "  #classifierMetrics(gee_ytest, gee_ypred)\n",
        "\n",
        "  # sklearn classifier\n",
        "  print('Run scikit-learn classifier ...')\n",
        "  forest, X_test, y_test = sklearnClassifier(training, testing)\n",
        "\n",
        "  y_pred = forest.predict(X_test)\n",
        "\n",
        "  print('Calculate feature importance ...')\n",
        "  # GEE feature importance\n",
        "  rf_explain = classifier.explain().getInfo()\n",
        "  gee_importance = pd.Series(rf_explain['importance']).sort_values(ascending=True)\n",
        "\n",
        "  # sklearn feature importance based on mean decrease in impurity, MDI\n",
        "  mdi_std = np.std([tree.feature_importances_ for tree in forest.estimators_],\n",
        "               axis=0)\n",
        "\n",
        "  mdi_importances = pd.Series(\n",
        "      forest.feature_importances_, index=feature_names\n",
        "  ).sort_values(ascending=True)\n",
        "\n",
        "  # sklearn feature importance based on feature permutation\n",
        "  permu_test_result = permutation_importance(\n",
        "            forest, X_test, y_test, n_repeats=5,\n",
        "            random_state=seed, n_jobs=5\n",
        "  )\n",
        "  permu_test_importances = pd.Series(\n",
        "      permu_test_result.importances_mean, index=feature_names\n",
        "  ).sort_values(ascending=True)\n",
        "\n",
        "  permu_train_result = permutation_importance(\n",
        "            forest, X_train, y_train, n_repeats=5,\n",
        "            random_state=seed, n_jobs=5\n",
        "  )\n",
        "  permu_train_importances = pd.Series(\n",
        "      permu_train_result.importances_mean, index=feature_names\n",
        "  ).sort_values(ascending=True)\n",
        "\n",
        "  # save permu importance to dataframe\n",
        "  sorted_test_idx = permu_test_result.importances_mean.argsort()\n",
        "  permu_test_df = pd.DataFrame(\n",
        "      permu_test_result.importances[sorted_test_idx].T,\n",
        "      columns=[feature_names[i] for i in sorted_test_idx],\n",
        "  )\n",
        "\n",
        "  sorted_train_idx = permu_train_result.importances_mean.argsort()\n",
        "  permu_train_df = pd.DataFrame(\n",
        "      permu_train_result.importances[sorted_train_idx].T,\n",
        "      columns=[feature_names[i] for i in sorted_train_idx],\n",
        "  )\n",
        "\n",
        "  # shap values\n",
        "  print('Calculate SHAP values ...')\n",
        "  explainer = shap.TreeExplainer(forest)\n",
        "  shap_values = explainer.shap_values(X_test) #shape(#classes, #samples, #features)\n",
        "\n",
        "  shap_obj = explainer(X_test)\n",
        "  #print(shap_obj.shape) # (#samples, #features, #classes)\n",
        "\n",
        "  #zonal areas calculation moved to specific tab, calculate only when requested\n",
        "  if temporal_interval == 'all-time':\n",
        "    ctab = cwidgets.TabBar([\n",
        "        'Labels histogram',\n",
        "        'Parallel coordinate plot',\n",
        "        'Classifier assessment',\n",
        "        'Feature importance',\n",
        "        'SHAP values',\n",
        "        'Zonal statistics'\n",
        "    ])\n",
        "  else:\n",
        "      ctab = cwidgets.TabBar([\n",
        "      'Labels histogram',\n",
        "      'Parallel coordinate plot',\n",
        "      'Classifier assessment',\n",
        "      'Feature importance',\n",
        "      'SHAP values',\n",
        "      'Zonal statistics',\n",
        "      'Spatio-temporal dynamics'\n",
        "  ])\n",
        "\n",
        "  color_barplot = 'blue'\n",
        "\n",
        "  # define widgets for interactive bar plots\n",
        "  # ? move to a separate section\n",
        "  # barplot widgets\n",
        "  w_barWidth = widgets.FloatSlider(\n",
        "        description='Bar width', value=0.5,\n",
        "        min=0.05, max=1, step=0.05,\n",
        "        continuous_update=False,\n",
        "        style=desc_width\n",
        "  )\n",
        "\n",
        "  w_rotation = widgets.IntSlider(\n",
        "      value=45,\n",
        "      min=0,\n",
        "      max=90,\n",
        "      step=1,\n",
        "      description='Label rotation',\n",
        "      continuous_update=False,\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  cm_normalize_options = [\n",
        "      ('normalized over the true conditions', 'true'),\n",
        "      ('normalized over the predicted conditions', 'pred'),\n",
        "      ('normalized by the total number of samples', 'all'),\n",
        "      ('not normalized', '-')\n",
        "  ]\n",
        "\n",
        "  # confusion matrix widget\n",
        "  w_cm_normalize = widgets.Dropdown(\n",
        "      options=cm_normalize_options,\n",
        "      value='-',\n",
        "      description='Confusion matrix',\n",
        "      layout={'width': 'max-content'},\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  # shap plot widgets\n",
        "  test_hist = testing.aggregate_histogram(LABEL).getInfo()\n",
        "  # in case some classes has zero sample\n",
        "  if len(test_hist.keys()) != len(CLASS_NAMES):\n",
        "    CLASS_NAMES_shap = [CLASS_NAMES[int(k)] for k in test_hist.keys()]\n",
        "    CLASS_PALETTE_shap = [CLASS_PALETTE[int(k)] for k in test_hist.keys()]\n",
        "  else:\n",
        "    CLASS_NAMES_shap = CLASS_NAMES\n",
        "    CLASS_PALETTE_shap =CLASS_PALETTE\n",
        "\n",
        "  w_shap_class = widgets.Dropdown(\n",
        "      options=CLASS_NAMES_shap,\n",
        "      value=CLASS_NAMES_shap[0],\n",
        "      description='Select class name',\n",
        "      layout={'width': 'max-content'},\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  w_shap_feature0 = widgets.Dropdown(\n",
        "      options=feature_names,\n",
        "      value=feature_names[0],\n",
        "      description='Main feature',\n",
        "      layout={'width': 'max-content'},\n",
        "      style=desc_width\n",
        "  )\n",
        "  w_shap_feature1 = widgets.Dropdown(\n",
        "      options=feature_names,\n",
        "      value=feature_names[1],\n",
        "      description='Interaction feature',\n",
        "      layout={'width': 'max-content'},\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  # spatio-temporal widget\n",
        "  w_zonal_selectClasses = widgets.SelectMultiple(\n",
        "      options=CLASS_NAMES,\n",
        "      value=CLASS_NAMES[:3],\n",
        "      description='Select classes',\n",
        "      rows=6,\n",
        "      disabled=False,\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  w_zonal_chartType = widgets.Dropdown(\n",
        "      options=['line', 'bar'],\n",
        "      value='line',\n",
        "      description='Chart type',\n",
        "      layout={'width': 'max-content'},\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  w_zonal_subplot = widgets.Checkbox(\n",
        "      description='Subplot',\n",
        "      value=False,\n",
        "      style=desc_width\n",
        "  )\n",
        "\n",
        "  # samples distribution\n",
        "  with ctab.output_to(0):\n",
        "    label_hist = LABEL_DATA.aggregate_histogram(LABEL).getInfo()\n",
        "\n",
        "    _ = interact(plotLabelsHist,\n",
        "             width=w_barWidth,\n",
        "             rot=w_rotation,\n",
        "             label_hist=fixed(label_hist)\n",
        "            )\n",
        "\n",
        "    # display labels numbers\n",
        "    train_hist = training.aggregate_histogram(LABEL).getInfo()\n",
        "    test_hist = testing.aggregate_histogram(LABEL).getInfo()\n",
        "\n",
        "    for c in label_hist.keys():\n",
        "      if c not in train_hist.keys():\n",
        "        train_hist[c] = 0\n",
        "      if c not in test_hist.keys():\n",
        "        test_hist[c] = 0\n",
        "\n",
        "    d = {\n",
        "      'All labels': label_hist.values(),\n",
        "      'Train labels': train_hist.values(),\n",
        "      'Test labels': test_hist.values()\n",
        "    }\n",
        "\n",
        "    class_index = [CLASS_NAMES[int(i)] for i in label_hist.keys()]\n",
        "\n",
        "    df = pd.DataFrame(d, index=class_index)\n",
        "    df.loc[\"Sum of classes\"] = df.sum()\n",
        "    #df.loc[:, \"Total\"] = df.sum(axis=1)\n",
        "    print('\\n', df)\n",
        "\n",
        "  # Parallel coordinate plot\n",
        "  with ctab.output_to(1):\n",
        "    print('\\nParallel coordinate plot for test data')\n",
        "    #train_data = geemap.ee_to_df(training)\n",
        "    test_data = geemap.ee_to_df(testing)\n",
        "\n",
        "    nClasses = len(CLASS_NAMES)\n",
        "\n",
        "    color_scale = []\n",
        "    for i in range(nClasses):\n",
        "      # f'{float(i)/nClasses:.2f}'\n",
        "      color_scale.append((float(i)/nClasses, CLASS_PALETTE[i]))\n",
        "      color_scale.append((float(i+1)/nClasses, CLASS_PALETTE[i]))\n",
        "\n",
        "    fig = px.parallel_coordinates(\n",
        "        test_data,\n",
        "        color=LABEL,\n",
        "        dimensions=feature_names+[LABEL],\n",
        "        color_continuous_scale=color_scale\n",
        "    )\n",
        "\n",
        "    fig.update_layout(coloraxis_colorbar=dict(\n",
        "        title=LABEL,\n",
        "        tickvals=list(range(nClasses)),\n",
        "        ticktext=CLASS_NAMES,\n",
        "        #lenmode=\"pixels\", len=150,\n",
        "    ))\n",
        "\n",
        "    fig.show()\n",
        "\n",
        "  # Classifier assessment\n",
        "  with ctab.output_to(2):\n",
        "    grid = cwidgets.Grid(1, 2)\n",
        "    with grid.output_to(0, 0):\n",
        "      #gee classifier metrics\n",
        "      display(widgets.HTML(\"<h3 style='text-align: center'>GEE metrics</h3>\"))\n",
        "      classifierMetrics(gee_ytest, gee_ypred)\n",
        "    with grid.output_to(0, 1):\n",
        "      #sklearn metrics\n",
        "      display(widgets.HTML(\"<h3 style='text-align: center'>Scikit-learn metrics</h3>\"))\n",
        "      classifierMetrics(y_test, y_pred)\n",
        "\n",
        "    #plotConfusionMatrix(normalize, gee_ytest, gee_ypred, y_test, y_pred)\n",
        "    print('\\n')\n",
        "    _ = interact(\n",
        "        plotConfusionMatrix,\n",
        "        normalize=w_cm_normalize,\n",
        "        gee_ytest=fixed(gee_ytest),\n",
        "        gee_ypred=fixed(gee_ypred),\n",
        "        y_test=fixed(y_test),\n",
        "        y_pred=fixed(y_pred)\n",
        "    )\n",
        "\n",
        "  # Feature importance\n",
        "  with ctab.output_to(3):\n",
        "    #ctab.clear_tab()  # clears current\n",
        "    grid = cwidgets.Grid(3, 1)\n",
        "    with grid.output_to(0, 0):\n",
        "      fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,6)) # figsize=(14,7)\n",
        "      gee_importance.plot.barh(ax=ax1, color=color_barplot)\n",
        "      ax1.set_title(\"GEE\")\n",
        "      ax1.set_xlabel(\"Decrease in impurity (sum)\")\n",
        "\n",
        "      mdi_importances.plot.barh(ax=ax2, color=color_barplot)\n",
        "      ax2.set_title(\"sklearn\")\n",
        "      ax2.set_xlabel(\"Mean decrease in impurity (normalized)\")\n",
        "\n",
        "      plt.suptitle(\"Impurity-based feature importance\", fontsize=14)\n",
        "      plt.show()\n",
        "\n",
        "    with grid.output_to(1, 0):\n",
        "      fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,6))\n",
        "      permu_train_importances.plot.barh(#xerr=permu_train_result.importances_std,\n",
        "                    ax=ax1, color=color_barplot)\n",
        "      ax1.set_title(\"Training data\")\n",
        "      ax1.set_xlabel(\"Mean decrease in accuracy\")\n",
        "\n",
        "      permu_test_importances.plot.barh(#xerr=permu_test_result.importances_std,\n",
        "                ax=ax2, color=color_barplot)\n",
        "      ax2.set_title(\"Testing data\")\n",
        "      ax2.set_xlabel(\"Mean decrease in accuracy\")\n",
        "\n",
        "      plt.suptitle(\"Permutation feature importance (barplot)\", fontsize=14)\n",
        "      plt.show()\n",
        "\n",
        "    with grid.output_to(2, 0):\n",
        "        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,6))\n",
        "        permu_train_df.boxplot(ax=ax1, grid=False, vert=False, color=color_barplot)\n",
        "        ax1.set_title(\"Training data\")\n",
        "        ax1.set_xlabel(\"Mean decrease in accuracy\")\n",
        "\n",
        "        permu_test_df.boxplot(ax=ax2,grid=False,  vert=False, color=color_barplot)\n",
        "        ax2.set_title(\"Testing data\")\n",
        "        ax2.set_xlabel(\"Mean decrease in accuracy\")\n",
        "\n",
        "        plt.suptitle(\"Permutation feature importance (boxplot)\", fontsize=14)\n",
        "        plt.show()\n",
        "\n",
        "    # plot shap values\n",
        "  with ctab.output_to(4):\n",
        "    print('\\nSHAP values summary plot for all classes')\n",
        "    # shap.summary_plot(shap_values, X_test, sort=True, show=False)\n",
        "    shap.summary_plot(shap_values, X_test,\n",
        "                      show=False, sort=True,\n",
        "                      #class_inds='original', # use default class order\n",
        "                      class_names=CLASS_NAMES_shap)\n",
        "\n",
        "    ax = plt.gca()\n",
        "    leg = ax.get_legend()\n",
        "\n",
        "    # len(CLASS_NAMES) may not equal shap_obj.shape[2], len(shap_values)\n",
        "    nclasses = len(shap_values)\n",
        "    nfeatures = int(len(ax.patches)/nclasses)\n",
        "\n",
        "    # https://github.com/slundberg/shap/blob/master/shap/plots/_beeswarm.py, line 845\n",
        "    class_inds = np.argsort([-np.abs(shap_values[i]).mean() for i in range(nclasses)])\n",
        "    #print('class order: ', class_inds)\n",
        "\n",
        "    for i, c in enumerate(class_inds):\n",
        "      start = i*nfeatures\n",
        "      end = (i+1)*nfeatures\n",
        "\n",
        "      for p in ax.patches[start:end]:\n",
        "        p.set_facecolor(CLASS_PALETTE_shap[c])\n",
        "\n",
        "      leg.legendHandles[i].set_color(CLASS_PALETTE_shap[c])\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "    # summarize the effects of all the features for one class\n",
        "    w_shap_figheight = widgets.FloatSlider(value=2.0)\n",
        "\n",
        "    def plotShapBar(shap_class):\n",
        "      ind = CLASS_NAMES_shap.index(shap_class)\n",
        "      shap.plots.bar(shap_obj[:,:,ind], show=False)\n",
        "      fig_width, fig_height = plt.gcf().get_size_inches()\n",
        "      w_shap_figheight.value = fig_height\n",
        "      plt.show()\n",
        "\n",
        "    def plotShapBeeswarm(shap_class, w_shap_figheight):\n",
        "      ind = CLASS_NAMES_shap.index(shap_class)\n",
        "      shap.plots.beeswarm(shap_obj[:,:,ind], show=False)\n",
        "      plt.gcf().set_figheight(w_shap_figheight)\n",
        "      plt.show()\n",
        "\n",
        "    def plotShapDependence(shap_class, main_index, interaction_index):\n",
        "      ind = CLASS_NAMES_shap.index(shap_class)\n",
        "      shap.dependence_plot(main_index, shap_values[ind], X_test,\n",
        "                      interaction_index=interaction_index)\n",
        "      #plt.suptitle('Dependence plot', size=14, weight='bold')\n",
        "      plt.show()\n",
        "\n",
        "    out_shap_bar = interactive_output(plotShapBar, {'shap_class': w_shap_class})\n",
        "    out_shap_beeswarm = interactive_output(\n",
        "        plotShapBeeswarm,\n",
        "        {'shap_class': w_shap_class,\n",
        "         'w_shap_figheight': w_shap_figheight}\n",
        "    )\n",
        "    out_shap_dependence = interactive_output(\n",
        "        plotShapDependence,\n",
        "        {'shap_class': w_shap_class,\n",
        "         'main_index': w_shap_feature0,\n",
        "         'interaction_index': w_shap_feature1}\n",
        "    )\n",
        "    print('\\n Shap values plot for selected class')\n",
        "    shap_grid = widgets.GridspecLayout(1, 2, layout=widgets.Layout(justify_content='center'))\n",
        "    shap_grid[0, 0] = out_shap_bar\n",
        "    shap_grid[0, 1] = out_shap_beeswarm\n",
        "    display(w_shap_class, shap_grid)\n",
        "\n",
        "    print('\\n Dependence plots for selected features')\n",
        "    display(\n",
        "        widgets.HBox([w_shap_feature0, w_shap_feature1]),\n",
        "        out_shap_dependence\n",
        "    )\n",
        "\n",
        "  # zonal statistics\n",
        "  with ctab.output_to(5):\n",
        "    print('Select compute checkbox to calculate zonal areas.')\n",
        "    w_zonal_compute = widgets.Checkbox(\n",
        "        value=False,\n",
        "        description='Compute',\n",
        "        disabled=False\n",
        "    )\n",
        "\n",
        "    display(w_zonal_compute)\n",
        "\n",
        "    def zonalComputeChanged(value):\n",
        "      if value['new']:\n",
        "        with ctab.output_to(5):\n",
        "          if temporal_interval == 'all-time':\n",
        "            print('Calculating zonal areas ...\\n')\n",
        "            zonal_dict = zonalStatistics(image_classified)\n",
        "            _ = interact(\n",
        "                plotZonalAreas,\n",
        "                width=w_barWidth,\n",
        "                rot=w_rotation,\n",
        "                zonal_dict=fixed(zonal_dict)\n",
        "            )\n",
        "          else:\n",
        "            if w_classified_tmpflag.value:\n",
        "              #colMosaic_tmp_classified = getClassifiedCollections()\n",
        "              df_tmpZonal = getClassifiedZonalAreas(classify=False)\n",
        "            else:\n",
        "              df_tmpZonal = getClassifiedZonalAreas()\n",
        "            print('\\n')\n",
        "            _ = interact(\n",
        "              plotTemporalZonal,\n",
        "              rot=w_rotation,\n",
        "              select=w_zonal_selectClasses,\n",
        "              chartType=w_zonal_chartType,\n",
        "              subplot=w_zonal_subplot,\n",
        "              df=fixed(df_tmpZonal)\n",
        "            )\n",
        "    w_zonal_compute.observe(zonalComputeChanged, 'value')\n",
        "\n",
        "  # spatio-temporal dynamics\n",
        "  if not temporal_interval == 'all-time':\n",
        "    with ctab.output_to(6):\n",
        "      colMosaic_tmp_classified = getClassifiedCollections()\n",
        "\n",
        "      desc_width1 = {'description_width': '160px'}\n",
        "\n",
        "      # widgets for thumbnail display\n",
        "      w_col_dates = widgets.SelectMultiple(\n",
        "          options=col_dates_list,\n",
        "          value=col_dates_list[:3],\n",
        "          rows=6,\n",
        "          description='Select dates',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_grid_column = widgets.BoundedIntText(\n",
        "          value=2,\n",
        "          min=1,\n",
        "          max=6,\n",
        "          step=1,\n",
        "          description='Image columns', #rows defined by number of dates selected\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_thumbnail_figsize = widgets.Text(\n",
        "          value='10, 8',\n",
        "          placeholder='In inches, separated by comma',\n",
        "          description='Figure size',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_thumbnail_dimension = widgets.BoundedIntText(\n",
        "          value=600,\n",
        "          min=200,\n",
        "          max=768,\n",
        "          step=1,\n",
        "          description='Thumbnail dimension',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_thumbnail = interactive(\n",
        "        plotClassifiedGrid,\n",
        "        {'manual': True, \"manual_name\": \"Plot thumbnails in grid\"},\n",
        "        select_dates=w_col_dates,\n",
        "        grid_column=w_grid_column,\n",
        "        figsize=w_thumbnail_figsize,\n",
        "        dim=w_thumbnail_dimension\n",
        "      )\n",
        "\n",
        "      w_btn_add2Map = widgets.Button(description='Add selected to map',\n",
        "                                button_style='',\n",
        "                                tooltip=\"Add classified image layers to map\")\n",
        "      w_add2Map_output = widgets.Output()\n",
        "      def btn_add_map_layers(obj):\n",
        "        # keep only the first 5 layers\n",
        "        Map.layers = Map.layers[:5]\n",
        "        layer_lim = 5\n",
        "\n",
        "        resultVis1 = {'min': 0, 'max': len(CLASS_NAMES)-1, 'palette': CLASS_PALETTE}\n",
        "\n",
        "        w_add2Map_output.clear_output()\n",
        "        with w_add2Map_output:\n",
        "          print('Add classified images (up to {}) to map ...'.format(layer_lim))\n",
        "\n",
        "          col_index = [col_dates_list.index(d) for d in w_col_dates.value]\n",
        "\n",
        "          for s in col_index[:layer_lim]:\n",
        "            result = ee.Image(listOfImages.get(s))\n",
        "            Map.addLayer(result, resultVis1, 'Classified {}'.format(col_dates_list[s]))\n",
        "\n",
        "          # re-assign vis parameters, since for an unknown reason, other info\n",
        "          # (such as region, crs, dimension) are added to resultVis after this\n",
        "          # addLayer operation\n",
        "\n",
        "          print('Done. Use map layer managers to explore.\\n')\n",
        "\n",
        "      w_btn_add2Map.on_click(btn_add_map_layers)\n",
        "\n",
        "      # widgets for gif export\n",
        "      w_gif_dimension = widgets.BoundedIntText(\n",
        "          value=600,\n",
        "          min=200,\n",
        "          max=768,\n",
        "          step=1,\n",
        "          description='dimension',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_gif_fps = widgets.BoundedIntText(\n",
        "          value=10,\n",
        "          min=1,\n",
        "          max=20,\n",
        "          step=1,\n",
        "          description='framesPerSecond',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_gif_fname = widgets.Text(\n",
        "          value='export_gif_classified',\n",
        "          description='GIF file name',\n",
        "          disabled=False,\n",
        "          style=desc_width1\n",
        "      )\n",
        "\n",
        "      w_btn_export_gif = widgets.Button(description='Export all to GIF',\n",
        "                                button_style='',\n",
        "                                tooltip=\"Export image collection as GIF\")\n",
        "      w_export_gif_output = widgets.Output()\n",
        "      def btn_export_gif(obj):\n",
        "        w_export_gif_output.clear_output()\n",
        "        with w_export_gif_output:\n",
        "          print('Export the classified image collections ...')\n",
        "\n",
        "          framesPerSecond = w_gif_fps.value\n",
        "\n",
        "          # Define arguments for animation function parameters.\n",
        "          video_args = {\n",
        "              'dimensions': w_gif_dimension.value,\n",
        "              'region': region,\n",
        "              'framesPerSecond': w_gif_fps.value,\n",
        "              'bands': ['vis-red', 'vis-green', 'vis-blue'],\n",
        "          }\n",
        "\n",
        "          out_gif = w_gif_fname.value + '.gif'\n",
        "\n",
        "          resultVis1 = {'min': 0, 'max': len(CLASS_NAMES)-1, 'palette': CLASS_PALETTE}\n",
        "\n",
        "          tmp_rgb = colMosaic_tmp_classified.map(lambda img: ee.Image(img).visualize(**resultVis1))\n",
        "          tmp_rgb = ee.ImageCollection(tmp_rgb)\n",
        "\n",
        "          geemap.download_ee_video(tmp_rgb, video_args, out_gif)\n",
        "\n",
        "          print('Adding dates to GIF ...')\n",
        "          geemap.add_text_to_gif(\n",
        "            out_gif,\n",
        "            out_gif,\n",
        "            text_sequence=col_dates_list,\n",
        "            font_color='#00ff00',\n",
        "            duration=1000 / framesPerSecond,\n",
        "          )\n",
        "          print('Done. Please check ' + out_gif)\n",
        "          print('\\n')\n",
        "\n",
        "      w_btn_export_gif.on_click(btn_export_gif)\n",
        "\n",
        "      w_export_gif = widgets.VBox([\n",
        "          w_gif_dimension,\n",
        "          w_gif_fps,\n",
        "          w_gif_fname,\n",
        "          w_btn_export_gif,\n",
        "          w_export_gif_output\n",
        "      ])\n",
        "\n",
        "      grid = cwidgets.Grid(2, 1)\n",
        "      with grid.output_to(0, 0):\n",
        "        #print('Export classified image collections')\n",
        "        display(widgets.HTML(\"<h3>Export classified image collections</h3>\"))\n",
        "        display(w_export_gif)\n",
        "      with grid.output_to(1, 0):\n",
        "        #print('Display image thumbnails at select dates')\n",
        "        display(widgets.HTML(\"<h3>Display image thumbnails at select dates</h3>\"))\n",
        "        display(w_thumbnail, w_btn_add2Map, w_add2Map_output)\n",
        "\n",
        "  #return ctab"
      ],
      "metadata": {
        "id": "a5VDNiCDXTgt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The APP"
      ],
      "metadata": {
        "id": "f0SHG54iciDV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def runApp():\n",
        "  \"\"\"\n",
        "  Main app function\n",
        "  \"\"\"\n",
        "\n",
        "  header = widgets.HTML(\"<h1 style='text-align: center'>An Explainable ML Land Cover Mapping with GEE</h1>\")\n",
        "\n",
        "  left_sidebar=widgets.VBox([\n",
        "        w_regions,\n",
        "        w_dates,\n",
        "        w_satellite,\n",
        "        w_select_bands,\n",
        "        w_source,\n",
        "        w_spectral_indices,\n",
        "        w_variables,\n",
        "        w_split_ratio,\n",
        "        w_classifier,\n",
        "        w_sample,\n",
        "        w_btn_classify,\n",
        "        #w_btn_features,\n",
        "        ], layout=widgets.Layout(width='28%')\n",
        "  )\n",
        "\n",
        "  app = widgets.VBox([\n",
        "      header,\n",
        "      widgets.HBox([left_sidebar,\n",
        "                    widgets.VBox([Map, w_btn_workflow_log],\n",
        "                                 layout=widgets.Layout(width='72%'))\n",
        "                  ]),\n",
        "\n",
        "      #bottom_tab,\n",
        "  ])\n",
        "\n",
        "  display(app)\n",
        "\n",
        "runApp()"
      ],
      "metadata": {
        "id": "tPie4V-UFmCH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Feature importance tab"
      ],
      "metadata": {
        "id": "SZ6RwCve414C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "createTabs()"
      ],
      "metadata": {
        "id": "tw2PPb_AzR4I"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}