diff --git a/Frequently_used_code/Combine_GEE_and_GA_data.ipynb b/Frequently_used_code/Combine_GEE_and_GA_data.ipynb new file mode 100644 index 000000000..d5f349f7b --- /dev/null +++ b/Frequently_used_code/Combine_GEE_and_GA_data.ipynb @@ -0,0 +1,659 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Combine data from Google Earth Engine (GEE) and Geoscience Australia (GA) \n", + "## Sentinel-1 example\n", + "* **Compatability:** Notebook currently compatible with the `DEA Sandbox` environment\n", + "* **Products used:** \n", + "[wofs_annual_summary](https://explorer.sandbox.dea.ga.gov.au/wofs_annual_summary)\n", + "[Sentinel-1 SAR GRD](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD)" + ] + }, + { + "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", + "\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/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Description\n", + "This notebook demonstrates how to access Sentinel-1 data stored in GEE and determine where water (basic water proxy for demonstration only) is present in the landscape.\n", + "\n", + "1. Install GEE API\n", + "2. Load python packages\n", + "3. Connect to datacube\n", + "4. Connect to GEE API\n", + "5. Load GEE imagery\n", + "6. Convert GEE image to numpy array\n", + "7. Load GA image\n", + "\n", + "***\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Install GEE API" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: earthengine-api in /env/lib/python3.6/site-packages (0.1.243)\n", + "Requirement already satisfied: six in /env/lib/python3.6/site-packages (from earthengine-api) (1.15.0)\n", + "Requirement already satisfied: httplib2shim in /env/lib/python3.6/site-packages (from earthengine-api) (0.0.3)\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: google-cloud-storage in /env/lib/python3.6/site-packages (from earthengine-api) (1.33.0)\n", + "Requirement already satisfied: future in /env/lib/python3.6/site-packages (from earthengine-api) (0.18.2)\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: 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: 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: 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.23.0)\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: google-resumable-media<2.0dev,>=1.0.0 in /env/lib/python3.6/site-packages (from google-cloud-storage->earthengine-api) (1.1.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.4.4)\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: 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: 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: 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: 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: 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: 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: 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: google-crc32c<2.0dev,>=1.0; python_version >= \"3.5\" in /env/lib/python3.6/site-packages (from google-resumable-media<2.0dev,>=1.0.0->google-cloud-storage->earthengine-api) (1.0.0)\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: 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.0.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.0.0->google-cloud-storage->earthengine-api) (2.20)\n", + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 20.3 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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load packages\n", + "Import Python packages that are used for the analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "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", + "\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": 22, + "metadata": {}, + "outputs": [], + "source": [ + "dc = datacube.Datacube(app='gee')" + ] + }, + { + "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": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Trigger the authentication flow.\n", + "ee.Authenticate()\n", + "\n", + "# Initialize the library.\n", + "ee.Initialize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Imagery" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define parameters " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Define parameters\n", + "\n", + "# Dates\n", + "# NOTE: GEE dates are inclusive and GA are exclusive on the end date\n", + "start = '2018-01-01'\n", + "end_ga = '2018-12-31'\n", + "end_gee = '2019-01-01'\n", + "\n", + "# Set the central latitude and longitude\n", + "central_lat = -35.294476\n", + "central_lon = 149.111817" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the buffer to load around the central coordinates\n", + "buffer = 0.05 # must be small for .sampleRectangle() to work\n", + "\n", + "# Compute the bounding box for the study area\n", + "study_area_lat = (central_lat - buffer, central_lat + buffer)\n", + "study_area_lon = (central_lon - buffer, central_lon + buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load GEE imagery\n", + "\n", + "To load imagery from GEE generally you will need to:\n", + "- define an area of interest and pass to `filterBounds`\n", + "- define a time period of interest and pass to `filterDate`\n", + "- select bands of interest\n", + "- reproject\n", + "\n", + "Imagery without a set projection will be called in WGS 94. Sentinel-1 pixels in GEE are 10m in length.\n", + "\n", + ">**Note**: All options for how to manipulate GEE objects can be found here https://developers.google.com/earth-engine/apidocs" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Define an area of interest.\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)\n", + "\n", + "# Filter image collection\n", + "img_VV_VH = (ee.ImageCollection('COPERNICUS/S1_GRD')\n", + " .filterBounds(aoi)\n", + " .filterDate(start,end_gee)\n", + " .filter(ee.Filter.listContains('transmitterReceiverPolarisation', 'VV'))\n", + " .filter(ee.Filter.eq('instrumentMode', 'IW'))\n", + " .select('VV','VH'))\n", + "\n", + "# Create a descending mean image\n", + "desc = (img_VV_VH.filter(ee.Filter.eq('orbitProperties_pass', 'DESCENDING'))\n", + " .mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'type': 'Image', 'bands': [{'id': 'VV', 'data_type': {'type': 'PixelType', 'precision': 'double'}, 'crs': 'EPSG:4326', 'crs_transform': [1, 0, 0, 0, 1, 0]}, {'id': 'VH', 'data_type': {'type': 'PixelType', 'precision': 'double'}, 'crs': 'EPSG:4326', 'crs_transform': [1, 0, 0, 0, 1, 0]}]}\n" + ] + } + ], + "source": [ + "print(desc.getInfo())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Smooth the sentinel imagery\n", + "We have already smoothed temporally, but we will also smooth spatially. A `focal_mean` is a simple way to achieve spatial smoothing." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Smooth imagery and reproject for comparison with WOfS\n", + "desc = (desc.focal_mean(2,'square','pixels')\n", + " .reproject('EPSG:3577',None,25))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Display GEE imagery on a folium map" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Map location in lats and lons\n", + "location=[central_lat, central_lon]\n", + "\n", + "# How zoomed in the map is\n", + "zoom_start=12\n", + "\n", + "# Set visualization parameters.\n", + "vis_params_vh = {\n", + " 'bands':['VH'], # check which abnds here https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR#bands\n", + " 'min': -25, # pixel value\n", + " 'max': 5 # pixel value\n", + "}\n", + "\n", + "# Set visualization parameters.\n", + "vis_params_vv = {\n", + " 'bands':['VV'], # check which abnds here https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR#bands\n", + " 'min': -25, # pixel value\n", + " 'max': 5 # pixel value\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define a method for displaying Earth Engine image tiles to folium map.\n", + "def add_ee_layer(self, ee_image_object, vis_params, name):\n", + " map_id_dict = ee.Image(ee_image_object).getMapId(vis_params)\n", + " folium.raster_layers.TileLayer(\n", + " tiles = map_id_dict['tile_fetcher'].url_format,\n", + " attr = \"Map Data © Google Earth Engine\",\n", + " name = name,\n", + " overlay = True,\n", + " control = True\n", + " ).add_to(self)\n", + "\n", + "# Add EE drawing method to folium.\n", + "folium.Map.add_ee_layer = add_ee_layer\n", + "\n", + "# Create a folium map object.\n", + "my_map = folium.Map(location=location, zoom_start=zoom_start, height=500)\n", + "\n", + "# Add the elevation model to the map object.\n", + "my_map.add_ee_layer(desc, vis_params_vv, 'VV mean')\n", + "my_map.add_ee_layer(desc, vis_params_vh, 'VH mean')\n", + "\n", + "# Add a layer control panel to the map.\n", + "my_map.add_child(folium.LayerControl())\n", + "\n", + "# Display the map.\n", + "display(my_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Convert GEE image into a numpy array\n", + "\n", + "The image returned to us is an ee.Image object. To integrate this with GA imagery, we need to convert the image object into an xarray." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ -8.17993624, -8.09810977, -8.32406336, ..., -8.94029872,\n", + " -8.79841064, -8.71372661],\n", + " [ -8.56012764, -8.3265096 , -8.41476743, ..., -9.22510119,\n", + " -8.80818164, -8.64615388],\n", + " [ -9.09762002, -8.66672289, -8.47694414, ..., -9.58073663,\n", + " -8.92451141, -8.68724723],\n", + " ...,\n", + " [ -9.0552432 , -8.64589681, -8.7726917 , ..., -16.1795608 ,\n", + " -16.52191048, -16.66358195],\n", + " [ -9.3732077 , -9.14393907, -9.30630861, ..., -16.35091341,\n", + " -16.66470253, -16.84776752],\n", + " [ -9.45056971, -9.20445057, -9.31362483, ..., -16.34371691,\n", + " -16.63140374, -16.93585538]])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get 2-d pixel array for AOI - returns feature with 2-D pixel array as property per band.\n", + "band_arrs = desc.sampleRectangle(region=aoi)\n", + "\n", + "# Get individual band arrays.\n", + "band_arr_vv = band_arrs.get('VV')\n", + "band_arr_vh = band_arrs.get('VH')\n", + "\n", + "# Transfer the arrays from server to client and cast as np array.\n", + "np_arr_vv = np.array(band_arr_vv.getInfo())\n", + "np_arr_vh = np.array(band_arr_vh.getInfo())\n", + "\n", + "# Print np_arr_vv to check\n", + "np_arr_vv" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot array\n", + "plt.imshow(np_arr_vh)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate where water is\n", + "### NOTE: Demo thresholds only ###\n", + "vh_water = np_arr_vh < -25\n", + "vv_water = np_arr_vv < -17\n", + "s1_water = vh_water & vv_water \n", + "\n", + "# Plot array\n", + "plt.imshow(s1_water)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load GA data" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# Load wofs_annual_summary\n", + "wofs = dc.load(\n", + " product=['wofs_annual_summary'],\n", + " x= study_area_lon,\n", + " y= study_area_lat,\n", + " time=(start, end_ga),\n", + " output_crs='EPSG:3577',\n", + " resolution=(-25,25),\n", + " resampling='cubic'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "wofs_water = wofs['count_wet'] > 2 \n", + "wofs_water = np.array(wofs_water[0,:,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Display wofs data\n", + "plt.imshow(wofs_water)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The imagery should now be comparable" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'S1 water (from GEE)')" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Display imagery side-by-side\n", + "f, (ax1, ax2) = plt.subplots(1,2)\n", + "ax1.imshow(np.array(wofs_water))\n", + "ax1.set_title('DEA Wofs')\n", + "ax2.imshow(s1_water)\n", + "ax2.set_title('S1 water (from GEE)')" + ] + }, + { + "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:** May 2020\n", + "\n", + "**Compatible datacube version:** " + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "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": "raw", + "metadata": { + "raw_mimetype": "text/restructuredtext" + }, + "source": [ + "**Tags**: :index:`sandbox compatible`, :index:`wofs`, :index:`landsat 8`" + ] + } + ], + "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 +}