diff --git a/Frequently_used_code/Compare_GEE_S2_Cloud_Prob_with_thresholds.ipynb b/Frequently_used_code/Compare_GEE_S2_Cloud_Prob_with_thresholds.ipynb new file mode 100644 index 000000000..2e6a20217 --- /dev/null +++ b/Frequently_used_code/Compare_GEE_S2_Cloud_Prob_with_thresholds.ipynb @@ -0,0 +1,654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare Sentinel-2 Cloud probability from Google Earth Engine (GEE) with FMASK from Geoscience Australia (GA) \n", + "* **Compatability:** Notebook currently compatible with the `DEA Sandbox` environment\n", + "* **Products used:** \n", + "[ga_s2a_ard_nbar_granule](https://explorer.sandbox.dea.ga.gov.au/ga_s2a_ard_nbar_granule)\n", + "[ga_s2b_ard_nbar_granule](https://explorer.sandbox.dea.ga.gov.au/ga_s2b_ard_nbar_granule)\n", + "[COPERNICUS_S2_CLOUD_PROBABILITY](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_CLOUD_PROBABILITY)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Background\n", + "GEE is a geospatial processing service. It has the option to be run through it's online JavaScript Code Editor, or can be accessed in python platforms such as Colab and Jupyter Notebooks. GEE provides access to many different datasets, climate data, PALSAR and MODIS (https://developers.google.com/earth-engine/datasets/catalog) which can be combined with data from DEA. \n", + "\n", + "To get started with GEE these links may help:\n", + "- User guides: https://developers.google.com/earth-engine/guides\n", + "- Get started using GEE with python: https://colab.research.google.com/github/google/earthengine-api/blob/master/python/examples/ipynb/ee-api-colab-setup.ipynb\n", + "- GEE developer guide for working with the S-2 cloud probability layer https://developers.google.com/earth-engine/tutorials/community/sentinel-2-s2cloudless\n", + "\n", + ">**Note**: You will need a Google Earth Engine account subject to their terms and conditions (https://earthengine.google.com/terms/). [Sign up here.](https://signup.earthengine.google.com/)\n", + "\n", + "This notebook is based on: https://developers.google.com/earth-engine/tutorials/community/sentinel-2-s2cloudless" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Description\n", + "This notebook demonstrates how to access Sentinel-2 Cloudless cloudmask, create a cloud shadow mask, load GEE and WMS layers within folium and finally load GEE image into numpy array to compare with DEA data.\n", + "\n", + "1. Install GEE API\n", + "2. Load python packages\n", + "3. Connect to datacube\n", + "4. Connect to GEE API\n", + "5. Set our Area of interest and thresholds for Sen2Cloudless\n", + "6. Create combined Cloud and Shadow mask from Sen2Cloudless within GEE\n", + "7. Observe behavior of these cloud masks in comparison with DEA FMASK data\n", + "6. Convert GEE image to numpy array\n", + "7. Load GA image\n", + "\n", + "***\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Install GEE API and GEEHydro for folium integration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: earthengine-api in /env/lib/python3.6/site-packages (0.1.249)\n", + "Requirement already satisfied: google-cloud-storage in /env/lib/python3.6/site-packages (from earthengine-api) (1.35.0)\n", + "Requirement already satisfied: google-api-python-client>=1.12.1 in /env/lib/python3.6/site-packages (from earthengine-api) (1.12.8)\n", + "Requirement already satisfied: future in /env/lib/python3.6/site-packages (from earthengine-api) (0.18.2)\n", + "Requirement already satisfied: httplib2<1dev,>=0.9.2 in /env/lib/python3.6/site-packages (from earthengine-api) (0.18.1)\n", + "Requirement already satisfied: google-auth-httplib2>=0.0.3 in /env/lib/python3.6/site-packages (from earthengine-api) (0.0.4)\n", + "Requirement already satisfied: httplib2shim in /env/lib/python3.6/site-packages (from earthengine-api) (0.0.3)\n", + "Requirement already satisfied: google-auth>=1.4.1 in /env/lib/python3.6/site-packages (from earthengine-api) (1.23.0)\n", + "Requirement already satisfied: six in /env/lib/python3.6/site-packages (from earthengine-api) (1.15.0)\n", + "Requirement already satisfied: requests<3.0.0dev,>=2.18.0 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api) (2.24.0)\n", + "Requirement already satisfied: google-resumable-media<2.0dev,>=1.2.0 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api) (1.2.0)\n", + "Requirement already satisfied: google-cloud-core<2.0dev,>=1.4.1 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api) (1.5.0)\n", + "Requirement already satisfied: google-api-core<2dev,>=1.21.0 in /env/lib/python3.6/site-packages (from google-api-python-client>=1.12.1->earthengine-api) (1.25.1)\n", + "Requirement already satisfied: uritemplate<4dev,>=3.0.0 in /env/lib/python3.6/site-packages (from google-api-python-client>=1.12.1->earthengine-api) (3.0.1)\n", + "Requirement already satisfied: certifi in /env/lib/python3.6/site-packages (from httplib2shim->earthengine-api) (2020.6.20)\n", + "Requirement already satisfied: urllib3 in /env/lib/python3.6/site-packages (from httplib2shim->earthengine-api) (1.24.3)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api) (4.1.1)\n", + "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3.5\" in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api) (4.5)\n", + "Requirement already satisfied: setuptools>=40.3.0 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api) (50.3.2)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api) (0.2.8)\n", + "Requirement already satisfied: idna<3,>=2.5 in /env/lib/python3.6/site-packages (from requests<3.0.0dev,>=2.18.0->google-cloud-storage->earthengine-api) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /env/lib/python3.6/site-packages (from requests<3.0.0dev,>=2.18.0->google-cloud-storage->earthengine-api) (3.0.4)\n", + "Requirement already satisfied: google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\" in /env/lib/python3.6/site-packages (from google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api) (1.1.2)\n", + "Requirement already satisfied: pytz in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api) (2020.4)\n", + "Requirement already satisfied: googleapis-common-protos<2.0dev,>=1.6.0 in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api) (1.52.0)\n", + "Requirement already satisfied: protobuf>=3.12.0 in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api) (3.13.0)\n", + "Requirement already satisfied: pyasn1>=0.1.3 in /env/lib/python3.6/site-packages (from rsa<5,>=3.1.4; python_version >= \"3.5\"->google-auth>=1.4.1->earthengine-api) (0.4.8)\n", + "Requirement already satisfied: cffi>=1.0.0 in /env/lib/python3.6/site-packages (from google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\"->google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api) (1.14.3)\n", + "Requirement already satisfied: pycparser in /env/lib/python3.6/site-packages (from cffi>=1.0.0->google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\"->google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api) (2.20)\n", + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 21.0 is available.\n", + "You should consider upgrading via the '/env/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\n", + "Requirement already satisfied: geehydro in /env/lib/python3.6/site-packages (0.2.0)\n", + "Requirement already satisfied: earthengine-api in /env/lib/python3.6/site-packages (from geehydro) (0.1.249)\n", + "Requirement already satisfied: click in /env/lib/python3.6/site-packages (from geehydro) (7.1.2)\n", + "Requirement already satisfied: folium in /env/lib/python3.6/site-packages (from geehydro) (0.11.0)\n", + "Requirement already satisfied: google-auth-httplib2>=0.0.3 in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (0.0.4)\n", + "Requirement already satisfied: six in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (1.15.0)\n", + "Requirement already satisfied: httplib2<1dev,>=0.9.2 in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (0.18.1)\n", + "Requirement already satisfied: google-api-python-client>=1.12.1 in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (1.12.8)\n", + "Requirement already satisfied: future in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (0.18.2)\n", + "Requirement already satisfied: google-cloud-storage in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (1.35.0)\n", + "Requirement already satisfied: httplib2shim in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (0.0.3)\n", + "Requirement already satisfied: google-auth>=1.4.1 in /env/lib/python3.6/site-packages (from earthengine-api->geehydro) (1.23.0)\n", + "Requirement already satisfied: requests in /env/lib/python3.6/site-packages (from folium->geehydro) (2.24.0)\n", + "Requirement already satisfied: branca>=0.3.0 in /env/lib/python3.6/site-packages (from folium->geehydro) (0.3.1)\n", + "Requirement already satisfied: numpy in /env/lib/python3.6/site-packages (from folium->geehydro) (1.18.5)\n", + "Requirement already satisfied: jinja2>=2.9 in /env/lib/python3.6/site-packages (from folium->geehydro) (2.11.2)\n", + "Requirement already satisfied: google-api-core<2dev,>=1.21.0 in /env/lib/python3.6/site-packages (from google-api-python-client>=1.12.1->earthengine-api->geehydro) (1.25.1)\n", + "Requirement already satisfied: uritemplate<4dev,>=3.0.0 in /env/lib/python3.6/site-packages (from google-api-python-client>=1.12.1->earthengine-api->geehydro) (3.0.1)\n", + "Requirement already satisfied: google-resumable-media<2.0dev,>=1.2.0 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api->geehydro) (1.2.0)\n", + "Requirement already satisfied: google-cloud-core<2.0dev,>=1.4.1 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api->geehydro) (1.5.0)\n", + "Requirement already satisfied: urllib3 in /env/lib/python3.6/site-packages (from httplib2shim->earthengine-api->geehydro) (1.24.3)\n", + "Requirement already satisfied: certifi in /env/lib/python3.6/site-packages (from httplib2shim->earthengine-api->geehydro) (2020.6.20)\n", + "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3.5\" in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api->geehydro) (4.5)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api->geehydro) (0.2.8)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api->geehydro) (4.1.1)\n", + "Requirement already satisfied: setuptools>=40.3.0 in /env/lib/python3.6/site-packages (from google-auth>=1.4.1->earthengine-api->geehydro) (50.3.2)\n", + "Requirement already satisfied: idna<3,>=2.5 in /env/lib/python3.6/site-packages (from requests->folium->geehydro) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /env/lib/python3.6/site-packages (from requests->folium->geehydro) (3.0.4)\n", + "Requirement already satisfied: MarkupSafe>=0.23 in /env/lib/python3.6/site-packages (from jinja2>=2.9->folium->geehydro) (1.1.1)\n", + "Requirement already satisfied: pytz in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api->geehydro) (2020.4)\n", + "Requirement already satisfied: protobuf>=3.12.0 in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api->geehydro) (3.13.0)\n", + "Requirement already satisfied: googleapis-common-protos<2.0dev,>=1.6.0 in /env/lib/python3.6/site-packages (from google-api-core<2dev,>=1.21.0->google-api-python-client>=1.12.1->earthengine-api->geehydro) (1.52.0)\n", + "Requirement already satisfied: google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\" in /env/lib/python3.6/site-packages (from google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api->geehydro) (1.1.2)\n", + "Requirement already satisfied: pyasn1>=0.1.3 in /env/lib/python3.6/site-packages (from rsa<5,>=3.1.4; python_version >= \"3.5\"->google-auth>=1.4.1->earthengine-api->geehydro) (0.4.8)\n", + "Requirement already satisfied: cffi>=1.0.0 in /env/lib/python3.6/site-packages (from google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\"->google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api->geehydro) (1.14.3)\n", + "Requirement already satisfied: pycparser in /env/lib/python3.6/site-packages (from cffi>=1.0.0->google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\"->google-resumable-media<2.0dev,>=1.2.0->google-cloud-storage->earthengine-api->geehydro) (2.20)\n", + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 21.0 is available.\n", + "You should consider upgrading via the '/env/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install earthengine-api\n", + "!pip install geehydro" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load packages\n", + "Import Python packages that are used for the analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import ee\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "import folium\n", + "import datacube\n", + "import geehydro\n", + "from functools import partial\n", + "from branca.element import Figure\n", + "from gee_sen2cloudless_utils import get_s2_sr_cld_col, add_cld_shdw_mask\n", + "\n", + "sys.path.append(\"../Scripts\")\n", + "from dea_plotting import rgb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Connect to the datacube\n", + "\n", + "Connect to the datacube so we can access DEA data.\n", + "The `app` parameter is a unique name for the analysis which is based on the notebook file name." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "dc = datacube.Datacube(app='cloud_prb_comparison')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Authenticate and initialize\n", + "\n", + "Run the `ee.Authenticate` function to authenticate your access to Earth Engine servers and `ee.Initialize` to initialize it. Upon running the following cell you'll be asked to grant Earth Engine access to your Google account. Follow the instructions printed to the cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Trigger the authentication flow.\n", + "ee.Authenticate()\n", + "\n", + "# Initialize the library.\n", + "ee.Initialize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Assemble cloud mask components\n", + "\n", + "This section builds an S2 SR collection and defines functions to add cloud and cloud shadow component layers to each image in the collection." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define collection filter and cloud mask parameters\n", + "\n", + "Define parameters that are used to filter the S2 image collection and determine cloud and cloud shadow identification.\n", + "\n", + "|Parameter | Type | Description |\n", + "| :-- | :-- | :-- |\n", + "| `central_lon` | float | Decimal longitude of area of interest |\n", + "| `central_lat` | float | Decimal latitude of area of interest |\n", + "| `start_date` | string | Image collection start date (inclusive) |\n", + "| `end_date` | string | Image collection end date (exclusive) |\n", + "| `cld_prb_thresh` | integer | Cloud probability (%); values greater than are considered cloud |\n", + "| `nir_drk_thresh` | float | Near-infrared reflectance; values less than are considered potential cloud shadow |\n", + "| `cld_prj_dist` | float | Maximum distance (km) to search for cloud shadows from cloud edges |\n", + "| `cloud_buffer` | integer | Distance (m) to dilate the edge of cloud-identified objects |\n", + "| `sample_buffer` | float | Buffer to use with GEE .sampleRectangle function. Must be relatively small as this has a cap of how many pixels it will return\n", + "| `map_buffer` | float | buffer size for displaying data from datacube oon map = adjust to your available RAM, data and patience\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "central_lon=152.30192184447827\n", + "central_lat=-28.268252634577337\n", + "\n", + "start_date = '2020-12-05'\n", + "end_date = '2020-12-06'\n", + "\n", + "cld_prb_thresh = 50\n", + "nir_drk_thresh = 0.15\n", + "cld_prj_dist =1\n", + "cloud_buffer = 50\n", + "\n", + "sample_buffer = 0.02\n", + "map_buffer = 0.2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compute bounding boxes for our applications" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute the bounding box for the study area\n", + "study_area_lat = (central_lat - sample_buffer, central_lat + sample_buffer)\n", + "study_area_lon = (central_lon - sample_buffer, central_lon + sample_buffer)\n", + "\n", + "# Compute the bounding box for the map area\n", + "map_area_lat = (central_lat - map_buffer, central_lat + map_buffer)\n", + "map_area_lon = (central_lon - map_buffer, central_lon + map_buffer)\n", + "\n", + "# Define an area of interest polygon for GEE\n", + "aoi = ee.Geometry.Polygon(\n", + " [[[study_area_lon[0], study_area_lat[0]],\n", + " [study_area_lon[0], study_area_lat[1]],\n", + " [study_area_lon[1], study_area_lat[1]],\n", + " [study_area_lon[1], study_area_lat[0]]]], None, False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### FMASK specific configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "sentinel_2_products = ['ga_s2a_ard_nbar_granule', 'ga_s2b_ard_nbar_granule']\n", + "cloud_measurement = \"fmask\"\n", + "de_sentinel_2_layername = \"Sentinel-2 FMASK\"\n", + "wms_url=\"https://ows.dea.ga.gov.au/wms\"\n", + "wms_display_name=\"GA Sentinel-2\"\n", + "wms_layer=\"s2_ard_granule_nbar_t\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve output_crs and resolution for retrieval from datacube" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "datasets = dc.find_datasets(product=sentinel_2_products,\n", + " x= study_area_lon,\n", + " y= study_area_lat,\n", + " time=(start_date, end_date))\n", + "\n", + "output_crs = datasets[0].metadata_doc['grid_spatial']['projection']['spatial_reference']\n", + "\n", + "gt = datasets[0].metadata_doc['image']['bands'][cloud_measurement]['info']['geotransform']\n", + "resolution = (gt[5],gt[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load cloud probability layer, then construct cloud and shadow mask with our thresholds" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "s2_sr_cld_col_eval = get_s2_sr_cld_col(ee, aoi, start_date, end_date)\n", + "s2_sr_cld_col_eval_disp = s2_sr_cld_col_eval.map(partial(add_cld_shdw_mask, ee, cld_prb_thresh, nir_drk_thresh, cld_prj_dist, cloud_buffer ))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot GEE imagery, cloud probabiliy and cloud mask on a map and compare with DE data" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "location=[central_lat, central_lon]\n", + "zoom_start = 12\n", + "\n", + "# Create a folium map object\n", + "my_map = folium.Map(location=location, zoom_start=zoom_start)\n", + "\n", + "# Add our WMS as a refence layer\n", + "folium.raster_layers.WmsTileLayer(\n", + " url=wms_url,\n", + " name=wms_display_name,\n", + " fmt=\"image/png\",\n", + " layers=wms_layer,\n", + " style='simple_rgb',\n", + " version='1.3.0',\n", + " time=start_date,\n", + " transparent = True,\n", + ").add_to(my_map)\n", + "\n", + "\n", + "# Mosaic the image collection.\n", + "img = s2_sr_cld_col_eval_disp.mosaic()\n", + "\n", + "# Subset layers and prepare them for display.\n", + "clouds = img.select('clouds').selfMask()\n", + "shadows = img.select('shadows').selfMask()\n", + "dark_pixels = img.select('dark_pixels').selfMask()\n", + "probability = img.select('probability')\n", + "cloudmask = img.select('cloudmask').selfMask()\n", + "cloud_transform = img.select('cloud_transform')\n", + "\n", + "# Add layers to the folium map.\n", + "my_map.addLayer(img,\n", + " {'bands': ['B4', 'B3', 'B2'], 'min': 0, 'max': 2500, 'gamma': 1.1},\n", + " 'S2 image')\n", + "my_map.addLayer(probability,\n", + " {'min': 0, 'max': 100},\n", + " 'probability (cloud)')\n", + "my_map.addLayer(clouds,\n", + " {'palette': 'e056fd'},\n", + " 'clouds')\n", + "my_map.addLayer(cloud_transform,\n", + " {'min': 0, 'max': 1, 'palette': ['white', 'black']},\n", + " 'cloud_transform')\n", + "my_map.addLayer(dark_pixels,\n", + " {'palette': 'blue'},\n", + " 'dark_pixels')\n", + "my_map.addLayer(shadows, {'palette': 'yellow'},\n", + " 'shadows')\n", + "my_map.addLayer(cloudmask, {'palette': 'orange'},\n", + " 'cloudmask')\n", + "\n", + "# load fmask for map in horrible projection\n", + "de_s2_cloudmask = dc.load(\n", + " product=sentinel_2_products,\n", + " measurements=[cloud_measurement],\n", + " lon= map_area_lon,\n", + " lat= map_area_lat,\n", + " time=(start_date, end_date),\n", + " output_crs='EPSG:3857',\n", + " resolution=resolution\n", + ")\n", + "\n", + "# reshape array for correct display\n", + "array = de_s2_cloudmask.isel(time=0).to_array().transpose(\"y\", \"x\", \"variable\").values \n", + "\n", + "folium.raster_layers.ImageOverlay(\n", + " image=array,\n", + " name=de_sentinel_2_layername,\n", + " bounds= [[map_area_lat[0], map_area_lon[0]],[map_area_lat[1], map_area_lon[1]]], \n", + " opacity=1,\n", + " interactive=False,\n", + " cross_origin=False,\n", + " zindex=4\n", + ").add_to(my_map)\n", + "\n", + "# Add a layer control panel to the map.\n", + "my_map.add_child(folium.LayerControl())\n", + "\n", + "#display folium map without ugly space beneath it\n", + "fig = Figure(width=800, height=800)\n", + "fig.add_child(my_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Combined cloudmask into numpy array" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "cloudmask = s2_sr_cld_col_eval_disp.select('cloudmask')\n", + "imgs = cloudmask.toBands()\n", + "bands = imgs.getInfo()['bands']\n", + "\n", + "cloud_np_arrays = []\n", + "for band in bands:\n", + " \n", + " gee_image = imgs.select(band['id'])\n", + " \n", + " #need to manually set a unsigned int8 default value, 0 isnt safe so will use 255\n", + " band_arrs = gee_image.sampleRectangle(region=aoi, defaultValue=255)\n", + "\n", + " band_arr_cloud = band_arrs.get('clouds')\n", + " \n", + " cloud_np_arrays.append((band['id'], np.array(band_arr_cloud.getInfo())))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Digital Earth cloud classification" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "de_cloud_data = []\n", + "\n", + "for dataset in datasets:\n", + " id = dataset.metadata_doc['id']\n", + " de_cloud_data.append((dataset.metadata_doc['tile_id'],dc.load(\n", + " id=id,\n", + " product=sentinel_2_products,\n", + " x= study_area_lon,\n", + " y= study_area_lat,\n", + " time=(start_date, end_date),\n", + " output_crs=output_crs,\n", + " measurements = [cloud_measurement],\n", + " resolution=resolution\n", + " )))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate some charts" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAKGCAYAAADEcdjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd5hc9X3v8fd3ZptWq7LqHUkgJBDNINMMmBhwxQ37muLYxnaCcezE1yWOYyfX5ebGieOS2E6MSdyNwR2X4LhgCLhA6EV0hEBdqGu10mp353f/mCM8bDlaaXc1W96v55lnZ36/U74z5+zMZ06bSCkhSZLUm0K1C5AkSUObYUGSJOUyLEiSpFyGBUmSlMuwIEmSchkWJElSLsOCJI1SEXFpRPxmkKa9MiLOHYxpD6V5jhaGhUMkIuoj4ksR8WRE7IyIuyPiJRX950TEQxHRGhE3RMRhFX2fjIhHs/Eeiog3dpn2CRFxRzbuHRFxQkXfH2XT2x4RK7uMNy0iro6ItVn/byPilC7DXJLVvCsiro2ISRV9N0bEnohoyW4PZ+0frGjbExGdFY+XZ8PMz+pqzZ7TuV3m++6IWB8ROyLiyxFRX9HX67gR8absNdgREasj4hMRUdPD8liU1fbNiraZEfHj7PVIETE/Z5FWTqs/y+cvI+L+bNwnIuIvu4yb91yPiYifR8SmiEhdxstd37Jh8ta5r0bE3orl1hIRxYh4fcXj3RFRqhwmG3dSRPwwW2eejIhLusw3b53qddyIeFlE/CYitmXrxn9ExLiK/k9ExKps2T8ZER/sMt8XRMSdWf+KiLhsP8u1L+vxyux12Nf+iy7TWBgRP82WwaaI+ERF340R8SfZ/bOzde6HXcY/Pmu/saItZa9PS0SsiYhPR0Qx77lI/ZZS8nYIbsBY4CPAfMoh7XxgZ/Z4CrAd+F9AA/BPwC0V434UWJKNdwqwFTg966sDngTeDdQDf5E9rsv6TwbeAFwGrOxS00LgPcBMoJgNswloyvqXZjWeBTQB3wKuqRj/RuBP9vO8LwV+00P774FPA2OA1wDbgKlZ34uADdn8m7P5/EMfx307cGb2uswG7gA+0MP8fwHcDHyzom068GfAaUAC5vdx2fZn+bwfOBGoARZnfRf18bkuBt4KvBJIfV3fsv79rXNfBf5uP8/7bGB1D+1XA9/O1pkzsvks7eM6lTfuJcCLgcZsvfgZcEXFuIuBsdn92cBy4ILscW02rbcBATwXaAGO7+MyvpSe1+OVwLm9jFMHPE75f2xs9jof19P/T/ZabgTWA5Mrhvk08DBwY0VbAo7I7i/Jxrn8IN+XenxeA3HLe20G61aNeY6WW9ULGM034N7sA+Ay4HcV7WOB3cCSXsb7MfDe7P4LgTVAVPQ/Bby4yzjn0iUs9DLtHcBJ2f2/B75V0Xc4sBcYlz1+5s0uZ3rd3oyAI4G2fdPJ2m7e94aXfYD8fUXfOcD6vozbw/zfA/ykS9tFwHcof5h+s4dxajiAsDAQy6ei77PA5w7kuQJH0CUs5K1v2f3cdY6DDAvZdPYCR1a0fYMs7OWtU/sbt4f5XwDc10vfbOA+4P3Z4+nZMm2sGOY24OI+LtNu63HWvpLew8JlwM0503zm/2ffawlcAbwjaytm687/oZewkD3+LvD5/dQ/F/gB8DSwed/wXZ8XcHr2umzP/p7e23Oly/8P5S8lT2bT/1Dl8Nmw3wW+STks3kd5/f5ryiFpFfDCimm9GXgwG3YF8LaKvinATykH5y2U/ycKXWsEjgKe6Osy9pZ/czdElUTEdMr/LMspf9u6Z19fSmkX5W8kS3sYbwzlb0XLs6alwL0p++/I3NvTuH2o6QTK34Yeq5h2ZV2Pk72ZV4z28Wzz6m8j4uw+zmopsCKltLOi7Z6Kmp813+z+9IiY3IdxuzqLP7xWRMR44GOUQ8SA68/yiYigvFWkctwDea55dVWub/umvb917s8iYku26+Q1fZzVkUBHSumRXmrOW6f2N25Xz1q2ABHxgWx3yGrK4eNb2Xw2UN5q8eZsd8ppwGHAQOyvvyoino6IX0TE8RXtpwIrI+Jn2f/IjRFx7H6m9XVg326sFwH3A2t7Gzgijqa8ztyVM0yR8ofrk5S3NM0GrulhuEnAf1IOrJMpb9X4z+z/LldWxxcoB4ZZ2fhzugz2csrhrzmr9+eUt3rNpvw/+cWKYTdS3ho2nnJw+ExEnJj1vZfy8p1KOQR+kHKAqqznxGz6f55Sunp/9Wv/DAtVEBG1wFXA11JKD1He5Lq9y2DbKX/b6uoKym+gP88eH8i4eTWNp/yP/NGU0r7p7W/af0V5V8Zs4ErgJxFxeB9mt7/pdu3fd39cH8Z9RkS8BVgGfLKi+f8CX0opre5DnQejP8vnI5T/J79yEOP2qof1rS/T/iywCJgG/C3w1Yh4Xh9m10R561Rv082b7/7GfUZEnAe8ifK37meklP4hG/5Eyutz5byuzoZvo/xt9EMppVV9eE55Xk/5A/gw4Abg5xExMeubQ3kr1mcpf4D+J/CjiKjrbWIppd8BkyJiMeXQ8PVeBr0zIrYCPwH+gz+sMz05OZv/X6aUdqWU9qSUegpJLwMeTSl9I6XUkX3IPkT5Q35/Xgv8NKV0U0qpjfI6U+oyzM0ppZ+nlDoob2WYSnmrUTvl8DJ/32uXUvrPlNLjqey/Ke82PDObTjvlXaeHpZTaU0o3dwnjZ1LeuvfGlNJP+1C7+sCwcIhFRIHym9he4J1ZcwvlBF1pPOVNcJXj/hNwDPC6in+OPo27n5rGUH7TuSWl9PGKrtxpp5RuTSntTCm1pZS+BvwWeGkfZrm/mrv277u/sw/j7ntOrwI+DrwkpbQpazuB8u6Yz/ShxgPWn+UTEe+k/OHwsuzNts/j7qemnta3/U47pXRnSmlz9qFxHeWwcUEfZnmgy7ayv6+v1amUtxi8tstWCLLaU0rpLsq7VT6ajbOE8gfSGylvPVsKvD8iXtaH59SrlNJvU0q7U0qt2f/ONv7wobab8ib+n6WU9lIOrZMpbx7P8w3Ky+qPgB/2MsyJKaXmlNLhKaW/SSl1/WCuNBd4MvuQzjOL8taHSk9S/jKwP7Mo70oAntlStbnLMBsq7u8GNqWUOiseQzkwEhEviYhbsi1b2yi/r0zJhvknyls/f5EdqPqBLvO5nPIuthv7ULf6yLBwCGWbmb9EedPZa7JEDeVNqcdXDDeW8r7cys3nHwVeQnm/XuW3r+XAcdm09zmOLptnc2qqB66lvFnvbV26u9a1kPJBet3eoDOJ8sFj+7McWFh5JHs2n+UV/cd36duQUtrch3GJiBcD/w68PKV0X8VwZ1P+FvhURKwH3ge8JiLu7EPNufqzfLItIB8AzumyxWO/z3U/NfW2vu2bdu4610Vfl+0jQE1ELOql5rx1an/jEhHPofyt8S0ppev3U0sN5ecE5RD3SPbNtpRSepjyN/2X9Dr2wal8ne6ly+bxPvoG5QNtr0sptQ5ATauAedHDWUFdrKW8haTSPMrHTQDsonxw6T4zKu6voxxKAIiIRsrB6IBl70nfpxyupqeUJgLXkb2u2ReU96aUFgKvAN4TEedUTOJyys93UL4UjFrVPGBitN0ob6K+hexsg4r2qZQ3l76G8hHT/8izj0z/a+BRYEYP09x3tP27KL/pvpNnH21fyKb5kqy9oaKvlvIWhWuBmh6mvZTyZuEzKe///SbZkevARMr7VBsovym/nvKbyZFdpnEpPR8YdgvlN4MG4NU8+yj/F1M+wvvobD6/5tlnQ+SN+wLK32jO6mGejZTf4PbdPgl8b9+42TAN2XNNlI+ub+jDcu3P8nl99lyP6mXaec81svajs3obgPr9rW99XOdeS/lbXoHyQZo7gbO7TONsej4b4hrKm/zHAs+j+9kQPa5TfRj3GMrfTi/sYZ4FymG3OXtdTqb8AfYXWf/hlLdcvCDrP5zyt9PL+vi/eyndD9Sdl9VYl72Gf0n5AMLJWf9ioJXy1qwi5TNiHq9Y9jfS5QDHimmfAczK7v8JOQc49qH2IuVdY5/kD2dlPK/r86L84b6N8lknNcCF2eMpWf9VlLfo1FLevbeJ7ADHbLm2ZHXXZfPq4NkHOFYeDPmsA675w0HFcyjvRuoEnp8tq5dkr+PfZcOeT/mg3qAcUNYBf5T1rcymPZHymVA9Hhzr7cBvVS9gtNwoJ/YE7Mn+qfbdXp/1n0t5/+Du7E1kfsW4ifJ+1srxPljR/5zsH2M3cCfwnIq+s7PxK283Zn3Pzx63dpn2mRXjX0L56P1dwI+ASVn7VMpHS+/M3lBuAc7r4Xk/82bUpX1+9jx3Uz417Nwu/e+h/MGwg/L+2Pq+jEt5v3FHl+fzs16WybPewCpe62fd+rBs+7N8nqC8D7Zy3Cv6+Fzn91Dvyr6sb31Y526m/EG9g/IHzUU9PO+z6TksTKIcQHdl684lXfp7XKf2N262HpS6PJ/lWV8B+C/KR8e3UN5K8UGefRbK6ygfMLiT8pa0fyQ7ir4Py/hSuoeFpZS3Huzb5H49sKzLMBdQDiU7std4aUXfjcBb817LrK9fYSEbZ172um6m/CH/2Z6eF+UP+zuyZX8HcEZF30Lg1uz13XcgZGUAeFO2zHo7G6JPYSF7/A7K///bKG9puYY/hIV3Z9PelS3Hv62YTuU8J1Fed//vgbxW3nq+RfaiSpIOoWz318dSStdWuxZpfzxmQZIOsYhYSvlAx15PeZSGEsOC1Afx7MseV97O3P/YGsoi4opelu0VgzS/f6R8KuBfpZS6nn1wsNOcl7OOzhuIeWh0czeEJEnK5ZYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5Rq0sBARL46IhyPisYj4wGDNR5IkDa5IKQ38RCOKwCPAecBq4Dbg4pTSAwM+M0mSNKhqBmm6JwOPpZRWAETENcArgR7DQl3UpwbGDlIpkiSNYOMaaZrbwqyaPf2azB33tm1KKU3tqW+wwsJsYFXF49XAKZUDRMRlwGUADTRySpwzSKVIkjTyRG0dUVfL7jOP5tx/vJm/mfJQv6ZXnPnYk731DVZY2K+U0pXAlQDjY9LA7wuRJGmkimDX+c9h9YsS42fs5Nym5UBx0GY3WGFhDTC34vGcrE2SJPVXFHj6OQV+99J/YlqxkWIMXlCAwTsb4jZgUUQsiIg64CLgx4M0L0mSRpdUoukp+ONHLuHd607h8faWQZ3doISFlFIH8E7g58CDwHdSSssHY16SJI06KTHt2keo/4sGbv2XZfxo53GDOrtBO2YhpXQdcN1gTV+SpNGsc9Nm2LSZcdNPZHvnmEGdl1dwlCRJuQwLkiQpV9VOnZQkSf1w6nFsPKmJnQtKvLOx10skDAjDgiRJw00Eq85p4nNv+SLza7Yzp6YeqB202RkWJEkahop74aG2WXSmAlOKO6gPw4IkSdonJeb+5yauXvFSth5Z5K/e9B3eOH7ToM3OAxwlSRqGOh94hLHfv5WZt+zh8bbpgzovw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJI0jEUpsbW9kU2du2gt7R2UeRgWJEkaxupWbuLmrz6X07/xPi5fdS6dqTTg8/A6C5IkDWMdT65i2r+upjhuHDdPXUxp3g0UB3geblmQJGm4S4m0dy9Nj9by6kfP5282HsvGzl0DNnnDgiRJI0CprY15X3+c0p+N4ydfOZM72yYN2LQNC5IkjQQp0bF+A50PPMK41Z38ftcR3Lt3D1s7W/s9acOCJEkjzIS7NvCzz5zFJVe8hw+tf0G/p+cBjpIkjTAdK1bSvGIlU2fP4jenLoDZt/RreoYFSZJGqNS6m9It8zk2XdKtLyLx6gX38jdT7qU28s+fiJTSYNXYZ+NjUjolzql2GZIkjSwRFCeMJ8aM6d5XLPLQe+dy+2s/TXOxkeLMx+5IKS3raTJuWZAkaaRKic5t22Hb9u59hSJj1h/Gt3YuZnKxJXcyhgVJkkajUifzfrKJqx97KakYwG29DmpYkCRplOp84BHGPrD/4Tx1UpIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyHXRYiIi5EXFDRDwQEcsj4l1Z+0ciYk1E3J3dXjpw5UqSpEOtph/jdgDvTSndGRHjgDsi4pdZ32dSSp/sf3mSJKnaDjospJTWAeuy+zsj4kFg9kAVJkmShoYBOWYhIuYDzwFuzZreGRH3RsSXI6K5l3Eui4jbI+L2dtoGogxJkjQI+h0WIqIJ+D7wv1NKO4AvAIcDJ1De8vCpnsZLKV2ZUlqWUlpWS31/y5AkSYOkX2EhImopB4WrUko/AEgpbUgpdaaUSsC/Ayf3v0xJklQt/TkbIoAvAQ+mlD5d0T6zYrBXA/cffHmSJKna+nM2xPOANwD3RcTdWdsHgYsj4gQgASuBt/WrQkmSVFX9ORviN0D00HXdwZcjSX1XnDqVjiNn01lf7NPwtTv3Eg+tpLRz5yBXJo0s/dmyIElVteuUBYx73yqe2/xkn4b/7uPPYe7H5sLdDwxyZdLIYliQNKRFbR1RVwuF7odYtU4r8tdzfs2LG/t2+nVrqY7bppxE/bhx3TtLJVJbG6mjo78lSyOOYUHS0BVByyuew5rzEtSUunUfNm8di2s3A019mtzLJtzNde84mpaLFnfrK7TUsPD7bRRuvqu/VUsjjmFB0pAVxSIblxW47WWfpLkwpsdhitG3oABwVgPcffI3e+z7bVuBdz/wdqbcfFClSiOaYUHSkFFctJAdx02lVFs+drpUhOIRLTREkWIMzI/k9jadqYVWth5Xov6iU2l6cjeF2x8kte8dkHlKw51hQdKQsfHs6Vzw579mccM6AIpRYlHt0zT1slVhIB1RW881L/s8q144mfddfxFHPdJE5+Ytgz5faTgwLEiqrgiKEycSjWNonRG8evxdHFXXWDHA4AcFgNoocnJ9kZPrd/DBSXug0LfTMaXRwLAgqaqKk5pZefkS6k/ewgvn/A+zanq6fIukajIsSKqqGDOGhlM2c+eyb2cth2ZLgqS+G5gjhiRJ0ohlWJAkSbncDSH1U9TWUZwzk9K4/M3nhZY9dK5a6+l4w8CEpt20L5lD7aQJpNXrKO3aVe2SpKoyLEj9VJwxjQffM4MTT3g8d7g7li/k6E9Ax4qVh6YwHbSPL/kBX/vE87ht9WHM+eyRXtVRo55hQeqrXk6lS+PHcvSxT/G9w3+VO/pFhRewbcLM/Z+Sl0qQ0sFWObwUilAsEDG0nu85Yzo5a94NfGnCPK6acj6N+x9FGtEMC1IfFI9axKrzp7J3YvcPtfYJJd4/7Tf7ncZLJ9/Lhy87grotJ/c+UIJpd5QY+9O7RvzuisIxS1j1sknsnlHizYfdWO1ynuWfthzOF24/m5q1dRy+Yhvdf5VCGl0MC1If7Fwyibdeeh1/PH55t74iQVOhHsjfYnDxuA288uX/Qnvq/aOnBJwy5d0s+VX9iA8L25dO5N2X/oALmlb06fU7lL7y0Gkc9ZGnKa3fSGlve7XLkarOsCD1JoLiEQtom9vMliVFFtWvZ0px7EFPrjaKTIj8gyA7U4mJM3ew+6wlFHd3DxW1W/cQDz5Oac+eg65jqEhFmFzTQnNx6G3k7+wskHbtHhGvszQQDAtSL6KujpUXzuCC197MkQ3rOKNhK4N9waBiFPjicd/gVx8/hvbU/Zv21+87hcUfnQWPrhjUOiSpkmFB6iqCwpgxxNix7J7TwYen3k1tFDlUVxY8ub6Wk+sf7rHv4QXT2Tx5LoW1Y0ltbaSOjkNS00CK+nqiro7OuqA2hl/90mhkWJC6qFlwGCveMIs989t47fG3UWDo/FbBRdNu5f3vmcPeDcew4NoOaq6/o9olHZCor2fLRSfy9BkdzJ23nqNrNwFN1S5L0n4YFqQu9s6ayHkvv43PzLyVYhQYShc6fcXYVl72vK9x3952Ln303Uy/vtoVHZioq+PpMzp46KX/Rg1FimFQkIYDw4KUKR59JNuXNrPtiCL/a+yaLCgMPcUoUBhi1yU4IJGyoDA0X19J3RkWJIAI1rxoCpf96U9YUr+WZfUt+OuHklRmWNDoVihSbJ5AjBlD64zEBU0PMrOmCYPC6NOZSjzV0cr2Ui17W+rKV9KUBBgWNMrVTJ/KY+9YQOOxW7nwsN8wqVhf7ZJUJSs7Wjnvhncx4bZ65j+2l9LOlmqXJA0ZhgWNaml8E/NPW8XPj/pp1lJb1XpUPU93jqH593VM+eLvABjGR4VIA86wIA1Dkwod7Dq1lQ2czoQVHTT++n5Kra3VLqtXNbNnsekFh9E6Izh2kReUkoYbw4I0DM0sNnLDGZ9ny+k1XPC7y1l8x/ghHRbaFs3gmHfcx3tm/JLpxRLFOPjLZks69AwLGpWKEyfArOm0LpjAnDGPVrucA1aMAnNqmpgDNDa2QWFon4ZYqgkWNG5iaZ0HjkrDkWFBo1LL2YvZe9kWjp38AJdPuwGoq3ZJkjRkGRY0ukRAFGiZUeTflnybUxuKDNeg0JlKlEikNHQuRz1ctadO9lL0qEapF4YFjRqFxka2v+I4Nh8T1B+zjVk1uxmuv0uwqXMXb3zsf/Hgw3NovqdI2rm62iUNW1ftnMyH73g5rGtgwQO7q12ONCQZFjRqxNixbHx5G7ec9XkaokhTYXgGBYANnQVW/3Q+S664h9TRQWdbW7VLGra+seZUFn1iLzzyCKU9vo5STwwLGvGKkyfRsXguO6c3MHfaeqYUh/+R+J0EhXYo7dpV7VL6pLalne8/cQKdqcC54+7neQ3VPSCzPXXyi91j+X3LIh5eMZOjt22kYwifTSJVm2FBI17bCQsofWAT5894gBc13Q94lcZDrfjASqb/3WHcMOV5/OBtx3Pnc6+q6g9JbS/t4Z2/ejuHf7uDJZtb6Fy3oWq1SMOBYUEj3t7xNbx17u+5dPxGDArV0bljB9x2H2PGjePJ1yyudjm0p8SYNTUUb7yNUvKoRml/hvbJ2ZIkqeoMC5IkKZe7IaRh5O62Nj634Rwe2DqdprWd1S5n2HmkfRf/vPEcHtw2naanErgLQuoTw4I0jHzh6bN59ONH0/zQFtjwEMaFA/Od7Sdx96dOYOI9mxmz8WFfP6mPDAsasYrjxxPjmmibUKAh2qtdTr+s62hhQ2ct92+ZyYRHt9H58GPVLumgRWuRO/Z2MrnQyryaMdRGcdDnubFzF2s7arh962GMW9lK54PD7/dApGoyLGhEito6Nly0lL0v2c7SaQ9zSsMqhuvVGltKezj/nrfQ+Ysp5V0P6x6pdkkHLe3ezcIftvO2h9/FtmM7+N6LPs9J9YMbFtpTJxc/fDGbfjqHsetLTHxihVsUpANkWNCIFMUCW48t8eDJX6M+ahmuQQFgT+pk532TWfCvt0Kpc1h/0KWODoo33Mm0G6DhklNZdc4kTqpvGdR5lijxxMMzWXzFnZT27BnWr59ULYYFaYi6d+8ePvDEBax4ejKTHkiQStUuaUA1PbWHd//3Rfzt5O5XTpw8tpWPHXEtZzX8oe3utjb+asVr2NjSxNsW3czlE9c807e1s5X3rz2PW9Ye1m1anZ0Fmu8pkDpH1usnHUqGBWmI+nnLUnb861wO/81KSjtbRtzFg4q3PchRj04gCt3P4N5z9Gy+9v/O4Kx5v3mm7Yc7TmTPP89i5kOb+NRHz+NPn//lZ64CuaKjhlu+ezzzrlrRfUYpUdr1JKX2vYP2XKSRzrCgESmlRN3WAlfvnM382k0sq2+lqdCw/xGHgEfad3Ff20x+teEoGte10bF+ZF6KOLW10blhY4999c3juW39XK5pbn6m7Yb1R9K4fjdp7QbS2mlc0zKVIuWtBfe2zqVxQ6Jj3fpDUrs02kQaAt9WxsekdEqcU+0yNJJEUDhuCTuOHM+m4wt87qL/4IWNQ/+MiM5U4qz7XkvHVdNp3NjOmDueoHPT5mqXdcgVxo2jfdkidk+te6atflsHDbc9Tuf2HcSJR7FzwViIAKC4t8S4u9fTsfKpapUsDXu/St+7I6W0rKc+tyxoZEqJ0j0P0nQPFDpOYe1rm4Gev8UOFZ2pRFvqYO1Tk1ly7f2Udu4ctQfjlXbupHjDnd0OS933eqTb76fp9mf3dRyKwqRRyrAgDQGPt7fwxgffyNqVU5j2uyJpr/vXJQ0dhgVpCFi+dxrtV09nyXfvIbV3kDwYT9IQYliQhoASBYrtiVJr99MIJana/NVJSZKUq99bFiJiJbCT8rFHHSmlZRExCfg2MB9YCbwupbS1v/OSRpq21M7O0l42dswiRuvRjJKGvIHaDfFHKaVNFY8/AFyfUvqHiPhA9vivBmhe0ojx95tO4KpfnsmYDQXm3r951J79IGloG6xjFl4JnJ3d/xpwI4YFqZsfrzyWxZ9bQ8dTq+kcAtc8kaSeDERYSMAvIiIBX0wpXQlMTymty/rXA9O7jhQRlwGXATTQOABlSENPe+rk6ztm85ONx/fYv2t5M2nX02BQkDSEDURYOCOltCYipgG/jIiHKjtTSikLEnRpvxK4EspXcByAOqQhpzXt5e/++xUs+QIZcD0AACAASURBVLcdRGf31XzR9qfo2LKtCpVJUt/1OyyklNZkfzdGxA+Bk4ENETEzpbQuImYy1C+dpxGtuLfE8tbZ3NvwFHOLJZqLA7slqz118lTHbnaWarv1bS410bC2htL9j0LJIxIkDU/9CgsRMRYopJR2ZvdfCHwM+DHwJuAfsr8/6m+h0sEau3wDN/3zqfzXjNN4zqvv5+uH3TSg01++t4NX/+LdTLy3e1iIUmLeXS0GBUnDWn+3LEwHfhjlH3OpAb6VUvqviLgN+E5EvBV4EnhdP+cjHbSOlU8xceVTTJ46lVtPmg8DHBae6mhm+k1FJlz1uwGdriQNFf0KCymlFUC3I7dSSpsBf0ZSkqQRwCs4SpKkXIYFSZKUy7AgSZJyGRY0qqRS0J466UylAZlee+qkPdXQ/UoikjRy+BPVGjVSayvjf93IkdvfzhGL1vH1RVczs6bpoKd3xbbZfOL2F1FcV8/hj7ZgXpA0UhkWNGqUdu1iylfvYOq3aln/5uNZ9d56ZvbjP+CrK09jyd9tJ61eR2lP28AVKklDjGFBo0pq30tq30vjhk4+sfolLBm3odsw02t38Opxy5lZbOT63fXc1LKkx2ltfGIyk3espLO1dbDLlqSqMixoVJpw0xPsWDObW+rmdevbsqSe9ncWuWziA1z+2z9hwdeCKHXfybDk6W10bt56KMqVpKoyLGhU6tywkdiwkWIPfVPaT2B5yyzWjruP2tX11Nz4Pz1ertkLOEsaLQwLUhe1Tz7NnV8/jldOOY7Zt+yFATpzQpKGK8OC1EXH6jVM+8La8oPkOQ6SZFiQemJIkKRneFEmSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5ao52BEjYjHw7YqmhcD/ASYCfwo8nbV/MKV03UFXKEmSquqgw0JK6WHgBICIKAJrgB8CbwY+k1L65IBUKEmSqmqgdkOcAzyeUnpygKYnSZKGiIEKCxcBV1c8fmdE3BsRX46I5p5GiIjLIuL2iLi9nbYBKkOSJA20foeFiKgDXgF8N2v6AnA45V0U64BP9TReSunKlNKylNKyWur7W4YkSRokA7Fl4SXAnSmlDQAppQ0ppc6UUgn4d+DkAZiHJEmqkoEICxdTsQsiImZW9L0auH8A5iFJkqrkoM+GAIiIscB5wNsqmj8REScACVjZpU+SJA0z/QoLKaVdwOQubW/oV0WSJGlI8QqOkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpSrT2EhIr4cERsj4v6KtkkR8cuIeDT725y1R0R8NiIei4h7I+LEwSpekiQNvr5uWfgq8OIubR8Ark8pLQKuzx4DvARYlN0uA77Q/zIlSVK19CkspJRuArZ0aX4l8LXs/teAV1W0fz2V3QJMjIiZA1GsJEk69PpzzML0lNK67P56YHp2fzawqmK41Vnbs0TEZRFxe0Tc3k5bP8qQJEmDaUAOcEwpJSAd4DhXppSWpZSW1VI/EGVIkqRB0J+wsGHf7oXs78asfQ0wt2K4OVmbJEkahvoTFn4MvCm7/ybgRxXtb8zOijgV2F6xu0KSJA0zNX0ZKCKuBs4GpkTEauDDwD8A34mItwJPAq/LBr8OeCnwGNAKvHmAa5YkSYdQn8JCSuniXrrO6WHYBLyjP0VJkqShwys4SpKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVIuw4IkScplWJAkSbkMC5IkKZdhQZIk5TIsSJKkXIYFSZKUy7AgSZJyGRYkSVKu/YaFiPhyRGyMiPsr2v4pIh6KiHsj4ocRMTFrnx8RuyPi7ux2xWAWL0mSBl9ftix8FXhxl7ZfAseklI4DHgH+uqLv8ZTSCdnt8oEpU5IkVct+w0JK6SZgS5e2X6SUOrKHtwBzBqE2SZI0BAzEMQtvAX5W8XhBRNwVEf8dEWf2NlJEXBYRt0fE7e20DUAZkiRpMNT0Z+SI+BDQAVyVNa0D5qWUNkfEScC1EbE0pbSj67gppSuBKwHGx6TUnzokSdLgOegtCxFxKXA+8PqUUgJIKbWllDZn9+8AHgeOHIA6JUlSlRxUWIiIFwPvB16RUmqtaJ8aEcXs/kJgEbBiIAqVJEnVsd/dEBFxNXA2MCUiVgMfpnz2Qz3wy4gAuCU78+Es4GMR0Q6UgMtTSlt6nLAkSRoW9hsWUkoX99D8pV6G/T7w/f4WJUmShg6v4ChJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJymVYkCRJuQwLkiQpl2FBkiTlMixIkqRchgVJkpTLsCBJknIZFiRJUi7DgiRJyrXfsBARX46IjRFxf0XbRyJiTUTcnd1eWtH31xHxWEQ8HBEvGqzCJUnSodGXLQtfBV7cQ/tnUkonZLfrACLiaOAiYGk2zr9FRHGgipUkSYfefsNCSukmYEsfp/dK4JqUUltK6QngMeDkftQnSZKqrD/HLLwzIu7NdlM0Z22zgVUVw6zO2rqJiMsi4vaIuL2dtn6UIUmSBtPBhoUvAIcDJwDrgE8d6ARSSlemlJallJbVUn+QZUiSpMF2UGEhpbQhpdSZUioB/84fdjWsAeZWDDona5MkScPUQYWFiJhZ8fDVwL4zJX4MXBQR9RGxAFgE/E//SpQkSdVUs78BIuJq4GxgSkSsBj4MnB0RJwAJWAm8DSCltDwivgM8AHQA70gpdQ5O6ZIk6VCIlFK1a2B8TEqnxDnVLkOSpFHrV+l7d6SUlvXU5xUcJUlSLsOCJEnKZViQJEm5DAuSJCmXYUGSJOUyLEiSpFyGBUmSlMuwIEmSchkWJElSLsOCJEnKZViQJEm5DAuSJCmXYUGSJOUyLEiSpFyGBUmSlMuwIEmSchkWJElSLsOCJEnKZViQJEm5DAuSJCmXYUGSJOUyLEiSpFyGBUmSlMuwIEmSchkWJElSLsOCJEnKZViQJEm5DAuSJCmXYUGSJOUyLEiSpFyGBUmSlKum2gVI0sEqjBtHzJkBEbB2A53btvc4XHH6NNLUST1+PSrsaKVz9VpSR8cgVysNX4YFScNW22mL2fqOFhrq2qm5cgmNP7y1+0CFIusvOJxZF66kodjerfvOO4/gqE+W6Fi1+hBULA1PhgVJQ1sERM97THdNr+Xvll7L1OJO3jbzXTQWit1Hr61h5wK46ogfMKEwplv/i/Y2kMY1Qg/jAlDq7Ff50khgWJA0dEXQft5JrH1eHakmde9e1MLCmi2MK5QovXArK2ef3G2YFHDUKU/QED2/3Z0/4z4+8/YXU7uj+7h1W4O5P9lI58OP9f+5SMOYYUHSkBXFImvOquW6N3yCCYXo1t8QRZoKjQD8dtlX2HNS960ARYL6qKE+6nqcx+UTV/DHr/oMnXQPI1/Zfhw/efQcxjzczyciDXOGBUlVFbV1xOKF7J02tltfqgna57YxvVhDU6EhdzpNhQaaDmL+tVGkudjYY9/i+nV87agaZuw4kbpVW+l8fCWk7qFCGukMC5KqqjBpIg+9fQJvOuPmbn3FKHHa2EcZ08tWgcF2ZsMm3n/pd3jowllc+70zmPeJNaT2vVWpRaomw4Kk6igUKYxpgInjmTJ/Cx+e+kDewIesrErNxUbeOH4TbePWcc2M06CHXSHSaGBYkFQVcdLRPPq6Jpi1h/cv/Hm1y5GUw7AgqSq2HzGWf3zlVbxq7DaKvZwaKWloMCxIOnQKReLEo9hxRBNPnxjMrtlKMXq5voGkIcOwIOmQKYxp4NELx/H3r/wW82q28Jz6EmBYkIY6w4KkQ6dQoLO5ndeM3bdFYfgEhTSmk+LsmaSduyht3epvSWhUcUehJO1HDUXeddqvWP8vdTz8wcMpLDys2iVJh5RhQZL2oxgF/nfzSu446Tu8/Kzb6ZhyMJd/koYvd0NIGnQ1s2ex6QWH0TojOHbRimqXI+kAGRYkDbq2RTM45h338Z4Zv2R6sUQxul/aWdLQZViQNOhKNcGCxk0srev+E9GShj6PWZAkSbkMC5IkKZdhQZIk5dpvWIiIL0fExoi4v6Lt2xFxd3ZbGRF3Z+3zI2J3Rd8Vg1m8JEkafH05wPGrwOeBr+9rSClduO9+RHwK2F4x/OMppRMGqkBJw1fN/Hm0LZjC5qX1zKzdVu1yJB2k/YaFlNJNETG/p76ICOB1wAsGtixJw16hyOpXzeHcN9zC4sb1vLzpccBTJqXhqL+nTp4JbEgpPVrRtiAi7gJ2AH+TUrq5pxEj4jLgMoAGGvtZhkaTqKkh6usBKO3eA6XOg59GoY+H7bS3U2prg5QOeF6jWdukxJ9M/g0zijC+4GmT0nDV37BwMXB1xeN1wLyU0uaIOAm4NiKWppR2dB0xpXQlcCXA+JjkO7D6rPO0Y1nxmnqiExZ+bzfx+3sOehqlpr79GFDj43XM/8aTdKxec8DzGrVSidn/vZcLOt7HnsP28h9nf4Vzxhx4sJNUfQcdFiKiBrgAOGlfW0qpDWjL7t8REY8DRwK397NO6RlblzTwpZd/kV2pjo/d/WYm/v7Ap7HlqAa+8oov8Lz6Up+Gf/3Kc9n+sxlgWOi7lKi5/g7m/TpoP+8kbn3uEZwz5uFqVyXpIPRny8K5wEMppdX7GiJiKrAlpdQZEQuBRYAXgteBiaBw/FFsXzweonv3luNKTC+20Jpq2PScRLH91AOexdbjSkwttFKMvu0CO27cGq45ZwlNS7rPq2ZPiXG3r3GrQ29SglKi1NPCHCY6U4nvtkzmOxuWcdejh3HUth24jUSjyX7DQkRcDZwNTImI1cCHU0pfAi7i2bsgAM4CPhYR7UAJuDyltGVgS9ZIF3V1PHHBBP72wu/QEO3d+ufWbuaI2npKlLjqVf/KmvObD3ge+6bRV5c138myt69gZ6n7fvcbth/FPR8/gUbDwojVQScfvPXVHPmZNo7e9jSda9dXuyTpkOrL2RAX99J+aQ9t3we+3/+yNBpFTQ2F5mZi3FjaZnTw2qb11EdtD0PuaytyagOUj6U9UD1Nt3dTimN5YWM70D28jCvcye+mn8j42bNIu3bRuW179wmMUoVx4yiMH0dLcw2Nhb3VLqd/ttfCA8vpaGurdiXSIecPSWnIKCw8jIcvn8rERVv48wXXU0Ox2iX1ybF1Wznmjcu550WzievnM/Pf76S0Z0+1y6q+CLa86hhaXrWDw6c8yYualgOeESENR4YFDRkdU5p4yZl38fnZt2Ytw+Nq5DNrmvj6YTfROa/EEZsvY1ZdHRgWIApsPQpuPfnfaS42YlCQhi/DgqQBVWxuZvu5R9Iyu8iE4zZRH8P/baZAgQVHrWPtO05i7PoSzdevoHPDxmqXJR0yw/+/WNLQMmsa8dan+daSq5haLNFYGP5XbayNIt9efDUbjijwoSdfxe7HpoNhQaOIYUHSgCg2N8PMqew8ciLHTb6HpXUja7fDlOJYphRhftNmHqiZMYxPBJUOnGFB0oDYft5i4i0bOW7yPVw+9UagodolSRoghgVVXwREgVQICtG3KyoOWQEUi1AoHtRvVgxL2fJrmV3gG0u+xXF1DRgUpJHFsKCq63z+c1jz/Ab2zGnnHRMerHY5B60YBV54zHJ+/YETaFwXzPnRGjqeeLLaZQ2qwrhxbH3lUrYeFYw/fhMziqMkIEmjjGFBVbfutAauvvQzLKgt0RT1DJdTJnvy2dk30XrJ9fz908/jzvtOpGakh4Xx49jxqhZ+e8oXaYgiTSPgYEZJ3Q3fd2WNGA2bE/+68QV8ffsS1nW2VrucfqmPWpqLjUyo2U0qjo5D4OprO5hSHEtTYWTverhpD3z46aX8fMVRFHcN86tRSgfILQuquhnXPcXKBxZx59HH0frndfzV5EerXZL0LG2pnT+97a3M/lIdh23eDY89Ve2SpEPKsKCq61i9hsLqNUwuHc+qPZOqXY7Uo/aNY6j777tJbW2kahcjHWLuhpAkSbkMC5IkKZe7ISTlKk6ZTOtzF7J3QvdfAW2bECydOnxPd5XUN4YFSbk6Fs+l/n3r+PO5N3Xrayjs5fi6TUDToS9M0iFjWFDVFcaOpTB+HC2T6hlb01btcgZEY2EvbRNrGDN7FqUdOynt3FntknIVGhspTBgPhe57JrfPrOfl0x7mNU07ehnboKBDK2pqKDQ3E3W1z7SltjY6t2wbPVdOPcQMC6q6HS87ls2v3cX8KWt43cT/AeqqXVK/vahpOTe9YxGPXjiFph8dxsRv3AJp6B5D3/qCY1hzyV7Gjd3TrW/uxCc5f9y9wMj6YSgNX4XD5/Pw26cwfsG2Z9paHmrmyCvWjvirplaLYUFVt3VRgV+c+gXm1TQxEoICwNK6MVy76OdsXdjKKY++l4lRgDR0v/FsX1jD9077HCfU1/cyhEFBQ0fHlCZedeb/8KmZdz7TdsmUP2LLNbOqWNXIZljQIVU8ahEbz5hCx5jy1Q1TQHHZNsaFJ+YcaoWGBlrPPY7tC2vYdWork4rtQG9hQTq0ikcfyYYzJtPZ0P1KqLtmJ97U9OwtCM9rfozPvnYJY848vdvwNbsS027aQOejKwat3pHOsKBDavNzp/An7/4xpzc+/kzb1EIHzUX3ex9qhYkTWHPJXn5w+meZVOhgZrGx2iVJz3j6lMm87d0/4tQx3T/gx0YHc2rqgT8cs/Dm8Y9z3h9/kj2p+1k7P9t5LD9qOYdxhoWDZljQgKuZMZ3SlOYer+LRMic4cczK7GeMVVXFIo2NbS6LHC2lPdze1sjK9tnUbXXr16ArFKmZNYPSpHHsmhOc1ND394rGQh1HFnrejfl04wq+Oe88Jhy3hMLmHXSsXTekjyEaigwLGlBRU8PqCw/nsAtWUFfo6Nb/xol3sLi2g8pvBNJQ9Zs9E3jXNW9hyj0lFjyyjdJef0BqMBXHN/H4nx7GMS94hDc338YRtQNznM/xdTu48A2/5s6Xz+Xh/1rEvH/eRql1eP9o3aFmWNDAiSDq6ti5sMQ1h/+Yxl5SvgfLDQGFIhQKjI7fxTx4a9qbmXpXibE/vJ1SKvltdLDV1pGWtPC9w3+VNQzMe8WU4lj+ZspDdE5+gEVHziPq62H3bpfnATAsaEDUzJ7F2lfOZ9fcxLKTHqE2uu831NBQXLqYVS+bTOuMEn+84OZqlzOkndDwFOtf00bxhJOZcWsnDdfd4Xn8w1gxCpx39AP8+gMn0LgumPOjNZ5q2UeGBQ2IjtmTWfrHD/C5udfRWKilNtzNMFRtP3oi77j0R1w47lGaCvWAwa43J9TVcPdZV7DtjA6e3/Q+Fv2yhtRmWBjOPjv7JlovuZ5/2HQ6t993EjWGhT4xLOiARX09sWQheyf/4ej5bYvqeH7TOpo9oh6AjZ27+MHOI3mgdRZj1g+tjf2pEEyqaXFZ9UExCjRFA7XRTqpxk/VIUB+11BdrOWrMWv7r2NOZWjqR+pWb3cKwH4YFHbDitKk88M4mLj35t8+0Ta/dzvlND+Olf8t+0nI4V1zxSqbetZs5q1bT4aZraUg5f+wTdL7tBzy0eyY//+ZpzPzn1e5iymFYUN8VihTGNFBqbuKIhev58NQHugxgUNhnXftEJj20l8LNd9H9nJDqiNo6oqGezvqgLnxT7IvOVKIltbG91Em0D60tRCNKoUihoZ4YO4ZisXRIZjmlOJa3TljP9nFP8KNppxKFIB2aWQ9LhgX1WTrtWB55bQOF6Xv4yJxfVrscHYCorWPrxSex8YwOZs/bwLF16zHc7d8dezu5+Dd/Rt3jY5h7WzupfahEv5GlcNxiHr9oAh2z2njnkhurXY56YFhQn21dPIYrX3ElZze0U/TyzMNK1NWy8fROlr/0X6mPGophUOiL+/bMZea1dYz9we89zW4QtSwYx3te8WP+dMIq31uGKJeKDkiR5D/zMFYbRZffAYoSBoVDoDY6q7JuFgmKh7ew7cJldJxzEsXx4w95DcOB7xqSpFGrqdDA9557JR/4yDfZ9OetMGdGtUsakgwLkqRRbWndGF41toVlM1axZ9Y4ambOoNDoqcWVDAuSJAFvmvYbin+9kUc+NYNd5x1T7XKGFMOCJEnAWQ3wy6N+wrWnf4HtCz3+v5KvhnJFfT1tZx/L1sV1bH9OG7NqdgJjq12W+qhm5gw2v2A+u2YWOGrxSvzpqL75+o4p/MujL2DLmokcucZfJxxtJhQ62X1KCxv+4nQmPNFB4/X3j/pfqTQsKFehsZGVrwl+9MJPM7HQwWwvETys7D18Bgv/7GE+NPs6phdLFMOg1xeffOg85nyoxPSNT1Dath3PhRhdZhYb+fXp/8aWU2t47e/fxqK7mg0L1S5AQ1whKI7t4Li6hmpXooMQnYl1reNZvncGtfVrmeJvRvWqPXVyRxusbJ/CzrXjYP1jdG7eUu2yVAXFKDCnpok5wGHTtrBn8QzqxzWSVq+ntHNntcurCsOCNILVPLKK9k8u5NNTL4ZLNvHb47/jdRZ68Vh7G5f857uZeXNw5FOtlHa0VLskDQF/u+AnfOX/ncmd6+cw+d8WU/uL26tdUlUYFrRf/7+9Ow+vqjoXP/5de58hwwmZ5wESCASQSZFBBanWonUApRfRtg7tvdRqrV5bbbX2Z/XXVtt622v1Vjtor1hFuVVRe3ECcUYrQ5gCMkNIQhLCkPkMe6/7xzlgIAMEkpyTnPfzPDxJ1tn7PO9ineHde03aDl51GSj5ojlJBhptKDDM4H9gmBb1seoO4HrzADHx8Ww+bzT2OC0bUnfAry1q7TiS1xt4Fq0AkK4HAQQHPU4v+IDFqR4eSv8GieEOKEwkWRBd0i2tJL8bw/Cm7zJkaDXPjHiWPIcsFXwik+O38Zd55+GaOpmcj3w4314lqwBGqGcbUrlv1eVQFUNhWUu4wxEiIkmyILpkNzeTtmAV6QsdVF83jh13eciTV80JzYjxs+bLj1Ft2Vxu/pAhSw3QstNjJHqmYgrFv/bBli3Yrd5whyNERJKPfXFC2u9D+32YPrC1Acg+ridSZ7fwUsNwyppziNkv0xUjmaUNnC0+rBOMdncUDsY7JBVHox9VtgO7qamPIhyglMIcOgRffjIHR5ikO+rDHZHogiQLQvSC1xqH8sQTs0hf00Je+V4CttxV6M+Uw8GeOblcfO0KluwcRcEDBbB2U7jD6teUw8muq7OZ/bUPKYmtZFrMfkCmZkcqSRaE6AVV/iRSNvswPlhDINzBhChLUW21kGCYeJRbBquGOA0LO86NkZDQ6THK4aA51+a+jODgx9WpZ+Lq6HjbRnu96ECktHoEMxTeVJubUj8m0TDxqMienu1UASy3wkhIQPt8aG90dVlJsiBEFNBeL/lvaC6qvYvA8GZePOcJWTsj5LqcFfy/H12Ov3FE5wcpuGRsKW7l5NLEtbz+vVE0HWh/vNHgoOglL8YHa3ox4oFB+wPkL7OYWX8XvqEtLDzvT0xyR24CO8q5n/h5VWyeWkL6Rw5SFq6OqoRBkgUhooAOBIj5x2cU/AMarp7M1okZjHVJHzHAvISD/Mu0/z7hccE7MSYzYm3WTn6mw2M+aHXww7LvkPpBz8Y4INkW7v/9jIIliqarJrF+Yj6T3PvCHVWnCp0elo1+icBoixL1XVJfdEmyIMQRyuFATxxFw5A46sZpUsxmQK5I+6UjUzc1WLJHxDG62yXT2fHpZhMHxtq45k3Bs7sFY+UmjPhYWicV05rsIPHzeuy1m2QabVtao/rJmGlTGcEFOKLw7SPJguiS4Yln89dj+c3M58h31jHCKUv6CNGZYU4Hz1/2GOUzU/nh0nmM3OJB52bQ8P16bi9exv9/YS5DrvoUsAAAHhpJREFUNjrRfl+4QxWiWyRZEF0zTYwUH3M89YAz3NFEvP1WE3sDDrY0ZWD4I/NyyfRpNrbksc5VTb5pkyybg/UYt3IyyQ2T3PX8LLsRnZ1Ba04CkzPX8TXPPu7NCmDmZYPP3+5c3dqKdfAwyMyZiOTXFnsCLdTZblRz9F00SbIgRA/61o457HqliPh9Nilb9kTMTIi2BpXu4/XfTefFrPOZPmc1f8j9JNwhDUh3jnyLP/x6BonuKr6R+jEOTG49ZxnP/n4ith3b7viW0iEMfXw7gX3VYYhWnMg6n8XX3vp3ktY5KSprRbdE12qfJ0wWlFL5wAIgk2BvzZ+01o8opVKAF4AhwC5grtb6oFJKAY8AXwWagRu01qt7J3whIoelbdZvy2PkXzZg1ddHZKIAENi5m+Sdu0nPzeHDKYUgyUKvuG7Qfq4b//fQX8Er0TtSdnBHyo4Oj58ROxv9t3iI3DF+Ua08kELm+yaJz34MRN/eISdzZyEA/EBrvVoplQCsUkq9DdwALNNaP6SU+jHwY+BHwCVAcejfZODx0E8hBqS9gUbuKr+cddU5JK1xoX2R3R/tKBpCzYxsmjMVX8pdFe5wRMj5mVtZdO35xFdmkvHhfqxNW8MdUp+Jq2jm5+9dwR9yD3Fb8TtcN2h/uEM6ZY6iIdScn40/of0oSEeTJuO9fVjbdn5Rlp1F3QVD8CYZZKxqhE/WHX3MiImh5cIxHBrqJHFHgLil67BbW/ukHsc7YbKgta4CqkK/NyilNgG5wCxgRuiwp4F3CSYLs4AFWmsNfKKUSlJKZYeeR4gBp8yXzOZnShj8yk50UzlWmN7MJ6t+fCaX3fYecxNXkuNQQPtb4qLv3Zm6ink3fsY7zSNY4L2MpChKFtSazxn500TISOHhX1zEdZMWhjukU1Y/LpOv3v4+cxLbJ+Kv1o/n9frz8bRJFvxFWRTd/Dnzs97j5r/eRP4/zaPjVoykRMqvCfDyeY9y1cc3MWJlIva+CE0W2lJKDQEmAJ8CmW0SgH0EuykgmEiUtzltb6jsmGRBKTUfmA8QI0t8Ri7Lwq5z8XxDMvnOOia6LdxKBjq2ZSqbQLzCTk/CMAxoaIjoqXGWUzEytoKRLnnfRRKPEcNIF1RbFViucEfTt7Tfh1Vbi2lbNFQO4/mGZIY49zPBbUfk542Zng4ZKWiz/d2D+gKTs+J2drjo2b647SzKv4BBY0uOlh0oiuXixN1McDfRkhPAGDsC7ODgaG9qHLnpBxnriiEv7RDekbk4M5LbPa9q8aHLK3v1rsNJJwtKKQ/wInC71ro+ODQhSGutlVLd+nTUWv8J+BPAIJUSuZ+sUc5ubGL4M808+sFc9p2jePnK/2SsK/LevOE0zlXP3OvfYfWsfD5/vZiCRw5hn2BTIiFEe3Z9I8MXtPLo8rlUTYfXLv9PRkfa541S1FwxjNRry0lwtf9ynj1oPVNiaoH4do+d6T7EnOvfZf2VOUfLRsVt4cqEdcSpWO67YDFLxo7B1sHv1wSnl+vTPwLggWGL+euD02jwu9s975rd+Qx/OAZKy3qoku2dVLKglHISTBSe1Vq/FCquPtK9oJTKBmpC5RVAfpvT80Jloh/SgQB8th7PZ5CSMJUDV8Qhu04eK82M5960zVipZQwbNhjlkElG4tQZykYbgGGCtiP6LlVP034ffLIOzyeQnDyV2q/G49ftp5kCOFXfTl80sNGGQjmcNBYolgx/gQyzfUIQ1HF5mhnPfellkH78l7oHgBsG1XDDoGUdnjs9BqYXdLw06H2DRvNh6hQcvfiaOZnZEAp4Etiktf5tm4deBa4HHgr9fKVN+feUUs8THNh4WMYrCCHEyck3G/FdcphdBZNIW6cZ9Gpp2Aa1hVNKWQv/ung+Vnz7i5PYtGb+MOE5ZsT23YVLsXM/hy9v5FDJWRRMKSeuj5OVrpwbv4UFX5+Ke/pkct/34ljW8wOXT+YS6Fzgm8B6pVRpqOwegknCIqXUt4HdwNzQY0sITpvcRnDq5I09GrEQQgxghU4PK85+itaJFpOW30risjiIwmTB+Hg9xavdoNqPC/BNKeH1h8cyI7a0gzN7x0hXHCvP+TP+qTZu5SDOiJxl7y+M9VL6lUepDGiusn9IwXKzxxf3OpnZEB/S+UrYF3ZwvAZuOc24hOiXktMbaJpeQsz+VsyyXVj1slmT6D6PEYMHMBx2h1+WUcG2Oh3746pr4bXtZ+BU7b8QYww/lyWsZby7fd/+6fJEUILQlqkMElUsfrMJ29E73VbSuSpEDzGVwRNj/sbSX57Bi7vHkfrLQtSKteEOS4iBZ+tuCh4cwicJZ7d7yJfoYNn3RrB89CsdnChOlSQL4qQpG2qsBPZblSQaMX0+wKg/mOR2Msn9OTaKdxLOk900wsjSNo3ai1d/0a/tRDHIiOn2LpP9hmFixAavfu2W1gG7z4Td1ASrNtLRJ5AnM4Mtc3OpKWnq8jkG/Guhh0myIE5aaulhHnjy69ydZXPLRW91umytEJGg1Bdg7kc349z+xaJT3nwffz3/qT4dGNeX9NQxbJkTTBaGvtiK+qjv+vQjhW5oJONVN9O33dnlcd4sP49c8CxXxMs055MhyYI4aXZpGblrFeawQl47Y4wkCyKirffmkb3YRfyLK46WeS+eyGeTCpkRuz2MkfWegyNiefyKvwDwkw3/SspHYQ4oDOzmZhIWfUrCiY6bPp6PJg3nivjoS6hOhSQLonu0Bq3ROkoHXQ0AcTU+7l9/GYuzKpmf9V5EXmVXBRp5tO4cyuqzT/k5NldnkF/tA60xxpZweGQSB0sMily1PRhp7xqeXUPNrOHEV1t4Vu4mUF0TrEtJYofDzuvGabIcDUd/d86b0v4gDYmbD2Ov2zxw13Dool7mqOEcHp3MoWEm/xJT0+lx/ZFTGehhzdTPO5u4fX5cn23BbmjokeeWZEGIKOP85+cM/nEmtTlD+NlPEnn3jMXhDqmdT71ZvP7keWQvrzvl5yjyNaErq9EOB3suS+HO6/7OEOd+Jrqbgcgc1X68J4YuovTHGTxXM4Wa+4twLT/IrlnJ3H3tIuKN9huW5TvrGOEM9uQ/f8WjlF+S2u6YJtvFgwvnMrjMGVwEKZooRcXMNOb/22uUuCuZ6G5kIO2N4lFuXp76BFsnpnPv+lkU3J0Jn0uyIETEijN8eJMcxObmYNc39Fh23xPspibYugNXcw7VzYnhDucYB61myi2DFY3jSSgPYG38/LSfUzkc2C4Y4txPjqMBp+o/Gy8UODwUOJo5kLqBx7NGEJuXTWt2gK95KokzOqrHF0NqJ7lhkrv91N1m28d92QHMvGx0YzP2wYPBlVqjhC8BrvJsItvhYSAlChCckTXaFctoVyOLMiupySnEXZ+Ffbj+tJegl2GgQvSCmZ6NpN+yk12/T+bAlWdE71z5bvphxVe49vE7ePd3U0lYV90jz6kti/w3m7jj4e/w1b//gKUtJ+rNjjzTYncweP4Wqh6J4eZpy3CrU7/OcysHN5+3jKpHYtjyo6EYQ/JPfJLod+ZnvYd1Tx2f/0cWLV8afdrPJ3cWhOgFo12xLC5+k4NFzUze+gOSlAF6YE5j60kr9g6h8OntBPZV02PXulqjVqwlfQUkzpxI2cxcLo3rXwMchzo9LCpaBkVHSk79Os9UBnembOfOlO18J2squ18Y1iMxisgyI9ZmxuhXKPV6uWHFvx/dFvpUSbIguq+hieqPhjGm6VouHryJ+zM+7eSWqBCdW9Zict/WWRxu+WL8gPnpIHRreRdnCdF9ZlIiDReUUJ9v4jrzIHGGrBHTXZIsiG6zamop/L0fFePm1VumcOt1H1AgyYLopj9WzSD2F4kkbvtinzndUoF1WJbIFj0sPZXmGw/yzJgFpBsBEg1PuCPqdyRZEN2nNdbBgwA4motOcHB0Omy3sNLrYau3GOfhyByvoAMBGmo9PN+QTJGrhgku47RW5dwTaGS1NwunCnC2u44MM54t/iZKvTnYuv1t8/VVORRWHSJQte90qiFOQ6qziQ2F8SQ2j4B9tVh1B8IdUo8ykxIhJ5OmoiRGpm5hrKt/zIKJRJIsCNEL/tGUxy+euZqUzRaDN9VhReCyu/ahwxT/1cejb19N5QU271zyWwqdp37Fdcfu2ez672L8HsXsb73HvWnr+MaGGzCeS8X0tz8+t8aHrhpY89z7m28mf0L9nbFsPJRFy9PDSfzbJ+EOqUc1fKkE/7/VMS5tPfPT3wPkDuipkmRBiF6w05tO1j99ON9aSeSlCUHa60V9vBYPkJh5DrUz3eR1MAjTQB1dP9/SNjYdL3hTVp1F4ZKd2OlJrJ+Tgzd1FbV7kil5eV2n07bCsRyU33bg19Yx9YpWI11xPJb7KTszGrk87y7aTaRVCpQB2u4fCzgdNxahMdvk8ZIXmBJjEtWJgiL4f3Ma7SjJghCCtA2tXLP4VuwOVnP0ZDbyxLi/McEV4KbyL/PBuhHQwQqeyaUmduNuDMNg6z+KGVP0fTI/NND+yJnDH7vnMAsWX8Cf86Zxw1kfc196WbhDilhmcjK1s0uoHwppa20SXi1Fe73hDqtT5shiyi9Nx5f8xZdhzOiD5DhagOgdo5Bp+jEv2s+uzEkkl2mSF68PrrXSTZIsCCEw31vL8E/dHa4H0XL+KJY/NIoRyav45N3RlPxyA9jtkwodCGB7vdiNjeQ+UocyTbQ/EFGrBFqbt1H4y3KM5CQW/GYy935pQ9TfXehUahLmv9Ty0ZinOXvp9xn5dgxWBCcLDSUp3HjDG1yXuP5oWYwy8UT5YMZsh4f3JiygdbzFeStuInWZR5IF0fdiazX3V17MmIS9XJWwgQJHdL8x+y3b6rSrwL2/lUU7JlCZm0RcpcJubOz6VqbWaK+3k86KMNMau7UV6htw7C7kpzXjMVT7SCfG7+SSuIO4VXRsMh6joDnPInDhWRxpuPosJ8OTy0gz48nKOkTTtBE4mtp3UznrvahNO0/pC+i0qeDGdt78ZA6UmIyIqSTNjO/7OCJYs+1jSXMm65oL8FfGn/JqnZIsiNOS+foe9mwaxtqRY2i8NYZ70zaHOyTRw4xNu8j5+WC2xo4kd085gf7Qd30CdksrQ5+u4Z9vT+zw8YWzz+XMqx6mwBEdyUKaGcujFz/NymlfzG5KMFu5LGE9EM9jJQtZ+svRtNrt/z+e2zyRoQ/kQQ8szd1dyuVi19VZzJ7zISWxlZzjPgDE9XkckWx3IMBPFl/L4CVeRtQcwD50+JSeR5IFcVoCeysw9laQ6htDWUM2+5NXEaecUbtIU7Pto1n7OeiPQ1n9/0sVCO5rsXIDBvTcqorhZltYW7Zjbun4Yc+Ec9gV8BCj2l8tO1EMMmIGVPeFU5lcGtfKpXHHj+EIXqWf5XZxlntrh+dW+waxNWUkjoQ2y2j7/cE7OL1MKUVrtsV9GatCd4EkUTieV5vElyvMd1ef1mBrSRZEj3BU1LH5mRLOzSth9PRtvDD0jdOas99f3br3Aj5YPoa4SkXujoqB8+UaZTI/beK7sTdjuds/5i3w8vT5TzJdpuwDMDt5FbffNoyWQyOOlg3a4CL3mc0Dbt2GaCbJgugRgYpK0v9YRabbTemvxuMvsqIuWbC0zTtlJYz89WasQ4cGxO36aKU+Xkveio4X0/JeMpGVZxcxPWZHH0cVmb4S52f91AXHlE3Nvhr1SgJIsjBgSLIgeo7W6ECAQdsNrtpyJWOSKrkt7QPywjzocZ2vlUerL6S2tXtxOAyLr2WsYl7CwaNlzbaPJw6V8H5dcbvjbRTxW1zB6WWSKPR/nbShCsfiEBHu+C6ZcWmVrLxkHLEHso+WJexoQq3e1CPbYZvJybRMHkZzuoPUwXUYsoFypxIMP4dHB4ibNwVPeSvGyk2nNAVWkgXRo3QgQM4L22BpEu9Mm8L4O/bw9YS6sMb0VN15bH7oDBK2HOrWea0xDn5y+2zmXPCXo3dJqiwff1w8k6ELO7hi0prBB3cQaGnpibCF6LceyH6T1XesotX+YuzSXUuuZcTmOKz609/7wx6ai76jlrsLlzLKVY1TyQyIzhQ4Yvn7zMfYdUEaP3zvakZuGYRVW9vt55FkQfQ4q7oGqmuIL55Eg9U3Hbv7rSYqLRO7g8WC1h7IxbP9MFY3R2sbMTEYVRNY5YUYFczEN/oGE1epuv1cQkSTbIeHSx2twBeDHO/JbobcTMzYGOwDh05r/Q3b7eCs1D3Mjm/kyCBM0TGnMjnLbXKWu56fpTWhHKfWPSzJghgQ5u+czbZXijE7GIAdX20RW9HxSO6u2D4/Q15r5bu7bg0ulwqYPk3WpwfCskyxEP3ZXWPf4o8PT6N2zxBK/tiILpXVM/sTSRbEgFC6o4CSJzdidTKH+JSmDNkWxgdryPjguOJTeS4hoty3E/fx7Qn/w28HF/HaKxdG804N/ZIkC6Lfqgo0cufeyyjdl8ugVW60r4OtDYXoCUqhzxlH7YQ46ofZjIqpCHdEQvQpSRZEv1XmT2Tjs6MY/NIOdFM5VifLFQtxupRpsntmLE9+4zGyzGbyHG4gOlZ3FAIkWRC9yNFksbRuJOmOBs50V1Lo7JkplHsDjaz0ZrH00Gjiqy0CVft65HmFOJ5yuzFzs7ES4/FmBxjn8kX9xkThZKalQmYaBwfHkOyUi4PuSo5rwTsiB9cgD7qyOrg660mSZEH0mpj15ex/sJBfZRSTct0e3ij53x553vurZrL6qbF4Ki0S1+yVVRJFrzEG51H2gxTOHr2Dn6eXEqukpz2c9l82nMRv7mVy0nauSVxJNG89fSoeGPYKTz14Hqur8sl6tBhz+eqTPleSBdFrrOoa3EtqiEtLZctFBfhHdDzM0EC1W9TF0jZ2J/sWrt2fQ9abFQR27ZFEQfQew8ROjGPa2M9ZMPj9I4VhDWkgMJSNNgDDBG2f/AJmStGYr3ileCHZDg+SKHTfjFibGYPfZ1FqIv+ZcQ0JxnHTKLsYCS7Jguh1urmFpOUxDG/4bvsHlWbyGdv5y+AleIzgmgx+bXFb5bm8vmYM2O3XTUjc6EAf3tTbYYsops8dz94L4mjJDfDNlI3hDmdAOTN2F7+/2sI1ZRLZHwdwvblSVjztYyWuavbPbqFu7KRjH7jnhU7PkWRB9Dq7uZm0p1eR/pwDVAeLJt05jkPfehVP6KLNq/28+eF4Rt6/Ce1vf+9ABwJYp7BcqRAnq3pSHH++8THOcHmJUy4guvY56U3num3WXPhfHLAsZjrvpGip2SNLQIuTN9rpYvW0P9J63rG3EjLv6fwcSRZEn9B+X6crtsVVau6vmkmmO7gMbKPlJq7CwG5skg8R0WeU04UaWYQvLZ6GQot8RzOJMpixx5nKIFHFYtKK7k4OpjUxtZqf7buIM+IruTJhY9j3nemvTGXgUTHd6siRZEGEXdaSPewqK2anI3hrQWlNwZ4KApIoiD5kpqVQdvMgbpj6IbfF7SLT7GB/ahFW2f9bzo6NJawcNR7/rSZ3pMjOn31FkgURdoG9FRh7j13kRtIE0WcMEyM2Bp2UQM6Q/dyXfmQZYllHIdIEyvdilO8l1R5PhTcp3OFEFUkWhBBRTU8+g61zYiGnlbsHvxHucISISJIsCCGi2uFhcfx21tNcGtfYbgqvECJI3hlCiOimwFS2JApCdEHeHUIIIYToknRDCCGE6DNe7Wd3wEdlIAGzpf26KyIySbIghBCizyxv8XDLqzeSuFVRUNqEtrpYY1hEDEkWhBBC9Jmy1lwK3rJwvfFZuEMR3SDJghAi6iinC9/5Yzgwys3hsT7yHYeAmHCHJU5AnT2G6rMTaBysud6zO9zhRBVJFoQQUceIjWHnHJOXL/4dKaafbDM23CGJE1GKii8l8Jv5T1LsrCPP4UYWzuo7MhtCCBF1tNYYLQYbfTmUB+KwscMdkjgJlhvGueoY6vTgVpIo9CVJFoQQUcduaqb4uUb+cO/XuP6lm1nb8R5nQogQ6YYQQkQf20Kv3IBnJQRip1I7OwFoDXdUUcFQNtoAjDZbTmobtD7xyRpaNfi1hVP1723DLW1jc2ydDdTRxcH8uvNZIuGouyQLQggh+syZsbv4/dUWznMnHS2LL4fsxTsI7Kvu/EStyVjj58LXfkBMVhN/mPAcM2L7b/fRT2vGs3D1JPCHbvA7bOaetZJfZqxmcVMSd6+6Ev/h9jufOhO9PHjWy8zx1PdpvJIsCCGE6DPnum3WXPhf+PUXX/Tzd86m+dMM6CpZAGLeXMOI5S58U0fy+sNjmRFb2tvh9gpL2ywsPZuR9+xBNzYBoOLiWPTgRH5+ySpeqDmbwt/ZGBs3tjtXjyrihd+dzRzPsj6NWZIFIYQQfcZUBonq2NknHqeX5pMYQacDAXQggNlqEbD7+ZA7S6GbW7CbgsmCARAI1ilgGxit/qOPtWW0+MNSd6VPpp+ot4NQqhbYDaQB+8McTl+KtvqC1DkaRFt9QeocDaKhvoO11ukdPRARycIRSqmVWuuJ4Y6jr0RbfUHqHA2irb4gdY4G0Vbf4/Xz+zhCCCGE6G2SLAghhBCiS5GWLPwp3AH0sWirL0ido0G01RekztEg2up7jIgasyCEEEKIyBNpdxaEEEIIEWEkWRBCCCFElyIiWVBKXayU+lwptU0p9eNwx9MblFL5SqnlSqkypdRGpdRtofKfKaUqlFKloX9fDXesPUUptUsptT5Ur5WhshSl1NtKqa2hn8nhjrOnKKVGtGnHUqVUvVLq9oHWxkqpp5RSNUqpDW3KOmxXFfT70Ht7nVLqzPBFfmo6qe9vlFKbQ3V6WSmVFCofopRqadPWT4Qv8lPXSZ07fR0rpe4OtfHnSqmZ4Yn69HRS5xfa1HeXUqo0VD4g2rk7wj5mQSllAluAi4C9wGfANVrrsrAG1sOUUtlAttZ6tVIqAVgFzAbmAo1a64fDGmAvUErtAiZqrfe3Kfs1cEBr/VAoMUzWWv8oXDH2ltDrugKYDNzIAGpjpdR0oBFYoLU+I1TWYbuGvlBuBb5K8P/iEa315HDFfio6qe9XgHe01gGl1K8AQvUdAvzjyHH9VSd1/hkdvI6VUqOAhcAkIAdYCgzXuoudkCJQR3U+7vH/AA5rrR8YKO3cHZFwZ2ESsE1rvUNr7QOeB2aFOaYep7Wu0lqvDv3eAGwCcsMbVVjMAp4O/f40wYRpILoQ2K613h3uQHqa1vp94MBxxZ216yyCH75aa/0JkBRKnPuNjuqrtX5Lax0I/fkJkNfngfWiTtq4M7OA57XWXq31TmAbwc/1fqWrOiulFMELu4V9GlQEiYRkIRcob/P3Xgb4l2goK50AfBoq+l7oduZTA+m2PKCBt5RSq5RS80NlmVrrqtDv+4DM8ITW6+Zx7AfLQG3jIzpr12h4f38LeL3N34VKqTVKqfeUUtPCFVQv6eh1HA1tPA2o1lpvbVM2kNu5nUhIFqKKUsoDvAjcrrWuBx4HhgLjgSrgP8IYXk87T2t9JnAJcEvoNt9ROtgHNuDm7iqlXMAVwP+EigZyG7czUNu1I0qpnwAB4NlQURVQoLWeANwBPKeUGhSu+HpYVL2Oj3MNxyb/A7mdOxQJyUIFkN/m77xQ2YCjlHISTBSe1Vq/BKC1rtZaW1prG/gz/fD2XWe01hWhnzXAywTrVn3kNnToZ034Iuw1lwCrtdbVMLDbuI3O2nXAvr+VUjcAlwFfDyVIhG7F14V+XwVsB4aHLcge1MXreMC2MYBSygFcBbxwpGwgt3NnIiFZ+AwoVkoVhq7I5gGvhjmmHhfq83oS2KS1/m2b8rb9t1cCG44/tz9SSsWHBnKilIoHvkKwbq8C14cOux54JTwR9qpjrkIGahsfp7N2fRW4LjQrYgrBAWJVHT1Bf6KUuhi4C7hCa93cpjw9NLgVpVQRUAzsCE+UPauL1/GrwDyllFspVUiwzv/s6/h60ZeBzVrrvUcKBnI7d8YR7gBCo4m/B7wJmMBTWuuNYQ6rN5wLfBNYf2T6DXAPcI1SajzB27a7gO+EJ7welwm8HMyRcADPaa3fUEp9BixSSn2b4Lbkc8MYY48LJUYXcWw7/nogtbFSaiEwA0hTSu0F7gMeouN2XUJwJsQ2oJngzJB+pZP63g24gbdDr/FPtNY3AdOBB5RSfsAGbtJan+xAwYjRSZ1ndPQ61lpvVEotAsoIdsnc0t9mQkDHddZaP0n78UcwQNq5O8I+dVIIIYQQkS0SuiGEEEIIEcEkWRBCCCFElyRZEEIIIUSXJFkQQgghRJckWRBCCCFElyRZEEIIIUSXJFkQQgghRJf+D+N/j5ZNvmHRAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for cloud_np_array in cloud_np_arrays: \n", + " # Plot array\n", + " plt.figure(figsize=(10, 10))\n", + " #why is this upside down?\n", + " plt.imshow(np.flipud(cloud_np_array[1]), vmin =0, vmax=1)\n", + " plt.suptitle(cloud_np_array[0])\n", + " plt.show()\n", + "\n", + "for de_cloud in de_cloud_data: \n", + " # Plot array\n", + " plt.figure(figsize=(10, 10))\n", + " plt.imshow(de_cloud[1][cloud_measurement].squeeze(),vmin=0,vmax=8)\n", + " plt.suptitle(de_cloud[0])\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## Additional information\n", + "\n", + "**License:** The code in this notebook is licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0). \n", + "Digital Earth Australia data is licensed under the [Creative Commons by Attribution 4.0](https://creativecommons.org/licenses/by/4.0/) license.\n", + "\n", + "**Contact:** If you need assistance, please post a question on the [Open Data Cube Slack channel](http://slack.opendatacube.org/) or on the [GIS Stack Exchange](https://gis.stackexchange.com/questions/ask?tags=open-data-cube) using the `open-data-cube` tag (you can view previously asked questions [here](https://gis.stackexchange.com/questions/tagged/open-data-cube)).\n", + "If you would like to report an issue with this notebook, you can file one on [Github](https://github.com/GeoscienceAustralia/dea-notebooks).\n", + "\n", + "**Last modified:** January 2021\n", + "\n", + "**Compatible datacube version:** " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.8.3\n" + ] + } + ], + "source": [ + "print(datacube.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tags\n", + "Browse all available tags on the DEA User Guide's [Tags Index](https://docs.dea.ga.gov.au/genindex.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Tags**: :index:`sandbox compatible`, :index:`sentinel 2`, :index:`GEE`, :index:`cloud masking`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Frequently_used_code/gee_sen2cloudless_utils.py b/Frequently_used_code/gee_sen2cloudless_utils.py new file mode 100644 index 000000000..44c43f6dc --- /dev/null +++ b/Frequently_used_code/gee_sen2cloudless_utils.py @@ -0,0 +1,75 @@ +# functions copied from https://developers.google.com/earth-engine/tutorials/community/sentinel-2-s2cloudless + +def get_s2_sr_cld_col(ee, aoi, start_date, end_date): + # Import and filter S2 SR. + s2_sr_col = (ee.ImageCollection('COPERNICUS/S2_SR') + .filterBounds(aoi) + .filterDate(start_date, end_date)) + + # Import and filter s2cloudless. + s2_cloudless_col = (ee.ImageCollection('COPERNICUS/S2_CLOUD_PROBABILITY') + .filterBounds(aoi) + .filterDate(start_date, end_date)) + + # Join the filtered s2cloudless collection to the SR collection by the 'system:index' property. + return ee.ImageCollection(ee.Join.saveFirst('s2cloudless').apply(**{ + 'primary': s2_sr_col, + 'secondary': s2_cloudless_col, + 'condition': ee.Filter.equals(**{ + 'leftField': 'system:index', + 'rightField': 'system:index' + }) + })) + +def add_cloud_bands(ee, img, cld_prb_thresh): + # Get s2cloudless image, subset the probability band. + cld_prb = ee.Image(img.get('s2cloudless')).select('probability') + + # Condition s2cloudless by the probability threshold value. + is_cloud = cld_prb.gt(cld_prb_thresh).rename('clouds') + + # Add the cloud probability layer and cloud mask as image bands. + return img.addBands(ee.Image([cld_prb, is_cloud])) + +def add_shadow_bands(ee, img, nir_drk_thresh, cld_prj_dist): + # Identify water pixels from the SCL band. + not_water = img.select('SCL').neq(6) + + # Identify dark NIR pixels that are not water (potential cloud shadow pixels). + sr_band_scale = 1e4 + dark_pixels = img.select('B8').lt(nir_drk_thresh*sr_band_scale).multiply(not_water).rename('dark_pixels') + + # Determine the direction to project cloud shadow from clouds (assumes UTM projection). + shadow_azimuth = ee.Number(90).subtract(ee.Number(img.get('MEAN_SOLAR_AZIMUTH_ANGLE'))); + + # Project shadows from clouds for the distance specified by the CLD_PRJ_DIST input. + cld_proj = (img.select('clouds').directionalDistanceTransform(shadow_azimuth, cld_prj_dist*10) + .reproject(**{'crs': img.select(0).projection(), 'scale': 100}) + .select('distance') + .mask() + .rename('cloud_transform')) + + # Identify the intersection of dark pixels with cloud shadow projection. + shadows = cld_proj.multiply(dark_pixels).rename('shadows') + + # Add dark pixels, cloud projection, and identified shadows as image bands. + return img.addBands(ee.Image([dark_pixels, cld_proj, shadows])) + +def add_cld_shdw_mask(ee, cld_prb_thresh, nir_drk_thresh, cld_prj_dist, cloud_buffer, img): + # Add cloud component bands. + img_cloud = add_cloud_bands(ee, img, cld_prb_thresh) + + # Add cloud shadow component bands. + img_cloud_shadow = add_shadow_bands(ee, img_cloud, nir_drk_thresh, cld_prj_dist) + + # Combine cloud and shadow mask, set cloud and shadow as value 1, else 0. + is_cld_shdw = img_cloud_shadow.select('clouds').add(img_cloud_shadow.select('shadows')).gt(0) + + # Remove small cloud-shadow patches and dilate remaining pixels by BUFFER input. + # 20 m scale is for speed, and assumes clouds don't require 10 m precision. + is_cld_shdw = (is_cld_shdw.focal_min(2).focal_max(cloud_buffer*2/20) + .reproject(**{'crs': img.select([0]).projection(), 'scale': 20}) + .rename('cloudmask')) + + # Add the final cloud-shadow mask to the image. + return img_cloud_shadow.addBands(is_cld_shdw) \ No newline at end of file