Folium/ee-api-folium-setup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"ee-notebook-buttons\" align=\"left\"><td>\n",
    "<a target=\"_blank\"  href=\"https://colab.research.google.com/github/giswqs/qgis-earthengine-examples/blob/master/Folium/ee-api-folium-setup.ipynb\">\n",
    "    <img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a>\n",
    "</td><td>\n",
    "<a target=\"_blank\"  href=\"https://github.com/giswqs/qgis-earthengine-examples/tree/master/Folium/ee-api-folium-setup.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td><td>\n",
    "<a target=\"_blank\"  href=\"https://nbviewer.jupyter.org/github/giswqs/qgis-earthengine-examples/blob/master/Folium/ee-api-folium-setup.ipynb\"><img width=26px src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/38/Jupyter_logo.svg/883px-Jupyter_logo.svg.png\" />Notebook Viewer</a></td><td>\n",
    "<a target=\"_blank\"  href=\"https://mybinder.org/v2/gh/giswqs/qgis-earthengine-examples/master?filepath=Folium%2Fee-api-folium-setup.ipynb\"><img width=58px src=\"https://mybinder.org/static/images/logo_social.png\" />Run in binder</a></td></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Earth Engine Python API and Folium Interactive Mapping\n",
    "\n",
    "This notebook demonstrates how to setup the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) in the [Google Colaboratory](https://colab.sandbox.google.com/notebooks/welcome.ipynb) platform (Colab) and provides several examples for visualizing Earth Engine processed data interactively using the [folium](https://github.com/python-visualization/folium) library. This notebook was adapted from the [ Earth Engine Python API example](https://github.com/google/earthengine-api/blob/master/python/examples/ipynb/ee-api-colab-setup.ipynb). \n",
    "\n",
    "**Contact:** Qiusheng Wu (<https://wetlands.io>)\n",
    "\n",
    "**Table of Contents**\n",
    "* [Install Earth Engine API and folium](#install-ee-folium)\n",
    "* [Import Earth Engine API and authenticate](#import-api)\n",
    "* [Static map](#static-map)\n",
    "* [Interactive map](#interactive-map)\n",
    "  * [Add custom basemaps](#add-basemaps)\n",
    "  * [Define add_ee_layer() function](#add-ee-layer)\n",
    "  * [Display ee.Image tiles](#display-ee-image)\n",
    "  * [A complete example](#a-complete-example)\n",
    "* [Chart visualization](#chart-vis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install Earth Engine API and folium <a class=\"anchor\" id=\"install-ee-folium\"></a>\n",
    "\n",
    "The Earth Engine API and folium library are installed by default in Google Colaboratory. You only need to install these two Python packages if you are running this notebook using your local Python interpreter.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip install earthengine-api\n",
    "!pip install folium"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Earth Engine API and authenticate<a class=\"anchor\" id=\"import-api\"></a>\n",
    "\n",
    "The Earth Engine API is installed by default in Google Colaboratory so requires only importing and authenticating. These steps must be completed for each new Colab session, if you restart your Colab kernel, or if your Colab virtual machine is recycled due to inactivity.\n",
    "\n",
    "### Import the API\n",
    "\n",
    "Run the following cell to import the API into your session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ee"
   ]
  },
  {
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Trigger the authentication flow. You only need to do this once\n",
    "ee.Authenticate()\n",
    "\n",
    "# Initialize the library.\n",
    "ee.Initialize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the API\n",
    "\n",
    "Test the API by printing the elevation of Mount Everest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mount Everest elevation (m): 8729\n"
     ]
    }
   ],
   "source": [
    "# Print the elevation of Mount Everest.\n",
    "dem = ee.Image('USGS/SRTMGL1_003')\n",
    "xy = ee.Geometry.Point([86.9250, 27.9881])\n",
    "elev = dem.sample(xy, 30).first().get('elevation').getInfo()\n",
    "print('Mount Everest elevation (m):', elev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Static map <a class=\"anchor\" id=\"static-map\"></a> \n",
    "\n",
    "`ee.Image` objects can be displayed to notebook output cells. The `IPython.display` module contains the `Image` function, which can display the results of a URL representing an image generated from a call to the Earth\n",
    "Engine `getThumbUrl` function. The following cell will display a thumbnail of the global elevation model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/a83efcc1cdfd60835e6ed06b44440762-f514cd45cea8208bc5bad681682ff9ff:getPixels\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import the Image function from the IPython.display module. \n",
    "from IPython.display import Image\n",
    "\n",
    "# Display a thumbnail of global elevation.\n",
    "Image(url = dem.updateMask(dem.gt(0))\n",
    "  .getThumbUrl({'min': 0, 'max': 4000, 'dimensions': 512,\n",
    "                'palette': ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive map <a class=\"anchor\" id=\"interactive-map\"></a> \n",
    "\n",
    "The [`folium`](https://python-visualization.github.io/folium/)library can be used to display `ee.Image` objects on an interactive [Leaflet](https://leafletjs.com/) map. Folium has no default method for handling tiles from Earth Engine, so one must be definedand added to the `folium.Map` module before use.\n",
    "\n",
    "The following cells provide an example of adding a method for handing Earth Engine tiles and using it to display an elevation model to a Leaflet map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the folium library.\n",
    "import folium\n",
    "from folium import plugins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add custom basemaps <a class=\"anchor\" id=\"add-basemaps\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add custom basemaps to folium\n",
    "basemaps = {\n",
    "    'Google Maps': folium.TileLayer(\n",
    "        tiles = 'https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}',\n",
    "        attr = 'Google',\n",
    "        name = 'Google Maps',\n",
    "        overlay = True,\n",
    "        control = True\n",
    "    ),\n",
    "    'Google Satellite': folium.TileLayer(\n",
    "        tiles = 'https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}',\n",
    "        attr = 'Google',\n",
    "        name = 'Google Satellite',\n",
    "        overlay = True,\n",
    "        control = True\n",
    "    ),\n",
    "    'Google Terrain': folium.TileLayer(\n",
    "        tiles = 'https://mt1.google.com/vt/lyrs=p&x={x}&y={y}&z={z}',\n",
    "        attr = 'Google',\n",
    "        name = 'Google Terrain',\n",
    "        overlay = True,\n",
    "        control = True\n",
    "    ),\n",
    "    'Google Satellite Hybrid': folium.TileLayer(\n",
    "        tiles = 'https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}',\n",
    "        attr = 'Google',\n",
    "        name = 'Google Satellite',\n",
    "        overlay = True,\n",
    "        control = True\n",
    "    ),\n",
    "    'Esri Satellite': folium.TileLayer(\n",
    "        tiles = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',\n",
    "        attr = 'Esri',\n",
    "        name = 'Esri Satellite',\n",
    "        overlay = True,\n",
    "        control = True\n",
    "    )\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define add_ee_layer() function <a class=\"anchor\" id=\"add-ee-layer\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a method for displaying Earth Engine image tiles on a folium map.\n",
    "def add_ee_layer(self, ee_object, vis_params, name):\n",
    "    \n",
    "    try:    \n",
    "        # display ee.Image()\n",
    "        if isinstance(ee_object, ee.image.Image):    \n",
    "            map_id_dict = ee.Image(ee_object).getMapId(vis_params)\n",
    "            folium.raster_layers.TileLayer(\n",
    "            tiles = map_id_dict['tile_fetcher'].url_format,\n",
    "            attr = 'Google Earth Engine',\n",
    "            name = name,\n",
    "            overlay = True,\n",
    "            control = True\n",
    "            ).add_to(self)\n",
    "        # display ee.ImageCollection()\n",
    "        elif isinstance(ee_object, ee.imagecollection.ImageCollection):    \n",
    "            ee_object_new = ee_object.mosaic()\n",
    "            map_id_dict = ee.Image(ee_object_new).getMapId(vis_params)\n",
    "            folium.raster_layers.TileLayer(\n",
    "            tiles = map_id_dict['tile_fetcher'].url_format,\n",
    "            attr = 'Google Earth Engine',\n",
    "            name = name,\n",
    "            overlay = True,\n",
    "            control = True\n",
    "            ).add_to(self)\n",
    "        # display ee.Geometry()\n",
    "        elif isinstance(ee_object, ee.geometry.Geometry):    \n",
    "            folium.GeoJson(\n",
    "            data = ee_object.getInfo(),\n",
    "            name = name,\n",
    "            overlay = True,\n",
    "            control = True\n",
    "        ).add_to(self)\n",
    "        # display ee.FeatureCollection()\n",
    "        elif isinstance(ee_object, ee.featurecollection.FeatureCollection):  \n",
    "            ee_object_new = ee.Image().paint(ee_object, 0, 2)\n",
    "            map_id_dict = ee.Image(ee_object_new).getMapId(vis_params)\n",
    "            folium.raster_layers.TileLayer(\n",
    "            tiles = map_id_dict['tile_fetcher'].url_format,\n",
    "            attr = 'Google Earth Engine',\n",
    "            name = name,\n",
    "            overlay = True,\n",
    "            control = True\n",
    "        ).add_to(self)\n",
    "    \n",
    "    except:\n",
    "        print(\"Could not display {}\".format(name))\n",
    "    \n",
    "# Add EE drawing method to folium.\n",
    "folium.Map.add_ee_layer = add_ee_layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display ee.Image tiles <a class=\"anchor\" id=\"display-ee-image\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"data:text/html;charset=utf-8;base64,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\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
      ],
      "text/plain": [
       "<folium.folium.Map at 0x7faa12c42710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set visualization parameters.\n",
    "vis_params = {\n",
    "  'min': 0,\n",
    "  'max': 4000,\n",
    "  'palette': ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']}\n",
    "\n",
    "# Create a folium map object.\n",
    "my_map = folium.Map(location=[20, 0], zoom_start=3, height=500)\n",
    "\n",
    "# Add custom basemaps\n",
    "basemaps['Google Maps'].add_to(my_map)\n",
    "basemaps['Google Satellite Hybrid'].add_to(my_map)\n",
    "\n",
    "# Add the elevation model to the map object.\n",
    "my_map.add_ee_layer(dem.updateMask(dem.gt(0)), vis_params, 'DEM')\n",
    "\n",
    "# Add a layer control panel to the map.\n",
    "my_map.add_child(folium.LayerControl())\n",
    "\n",
    "# Add fullscreen button\n",
    "plugins.Fullscreen().add_to(my_map)\n",
    "\n",
    "# Display the map.\n",
    "display(my_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A complete example <a class=\"anchor\" id=\"a-complete-example\"></a> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"data:text/html;charset=utf-8;base64,<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    
        <script>
            L_NO_TOUCH = false;
            L_DISABLE_3D = false;
        </script>
    
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.5.1/dist/leaflet.js"></script>
    <script src="https://code.jquery.com/jquery-1.12.4.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.5.1/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawcdn.githack.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
            <meta name="viewport" content="width=device-width,
                initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
            <style>
                #map_5b1400700d1f43c095be29c653d71259 {
                    position: relative;
                    width: 100.0%;
                    height: 500.0px;
                    left: 0.0%;
                    top: 0.0%;
                }
            </style>
        
    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet.fullscreen/1.4.2/Control.FullScreen.min.js"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.fullscreen/1.4.2/Control.FullScreen.min.css"/>
</head>
<body>    
    
            <div class="folium-map" id="map_5b1400700d1f43c095be29c653d71259" ></div>
        
</body>
<script>    
    
            var map_5b1400700d1f43c095be29c653d71259 = L.map(
                "map_5b1400700d1f43c095be29c653d71259",
                {
                    center: [40.33, -99.42],
                    crs: L.CRS.EPSG3857,
                    zoom: 4,
                    zoomControl: true,
                    preferCanvas: false,
                }
            );

            

        
    
            var tile_layer_75f314d90c0a4ae2b8098671bb9e1def = L.tileLayer(
                "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
                {"attribution": "Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://www.openstreetmap.org/copyright\"\u003eODbL\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            var tile_layer_48461024e85f43a0bcee45cf8b4825c2 = L.tileLayer(
                "https://mt1.google.com/vt/lyrs=m\u0026x={x}\u0026y={y}\u0026z={z}",
                {"attribution": "Google", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            var tile_layer_9855b16395be407d8d497532f2c11130 = L.tileLayer(
                "https://mt1.google.com/vt/lyrs=y\u0026x={x}\u0026y={y}\u0026z={z}",
                {"attribution": "Google", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            var tile_layer_208fb6684efc466e9c03fd06f679dace = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/b12f699b32f7dbd5efc7057b006d1953-b6199c66986120c668a0db2a120f0dee/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            var tile_layer_e5633b4ab72a43bd8988a22f09f12946 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/ec4b64424e952849df531e926dde87a7-87d1db9561ed8415f475d1fea90676a5/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
        function geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2_onEachFeature(feature, layer) {
            layer.on({
                click: function(e) {
                    map_5b1400700d1f43c095be29c653d71259.fitBounds(e.target.getBounds());
                }
            });
        };
        var geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2 = L.geoJson(null, {
                onEachFeature: geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2_onEachFeature,
            
        });
        function geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2_add (data) {
            geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2.addData(data)
                .addTo(map_5b1400700d1f43c095be29c653d71259);
        }
            geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2_add({"coordinates": [[[-35, -10], [-35, 10], [35, 10], [35, -10], [-35, -10]]], "type": "Polygon"});
        
    
            var tile_layer_a5e50aff46c948f7b3eba2e8301a9433 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/a6f77aeb181cb5d4740c338446a88a70-a8c06225eda25ce19d7a226a66c5c545/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            var layer_control_156c6d0f4771479498bee6ab91d49839 = {
                base_layers : {
                    "openstreetmap" : tile_layer_75f314d90c0a4ae2b8098671bb9e1def,
                },
                overlays :  {
                    "Google Maps" : tile_layer_48461024e85f43a0bcee45cf8b4825c2,
                    "Google Satellite" : tile_layer_9855b16395be407d8d497532f2c11130,
                    "DEM" : tile_layer_208fb6684efc466e9c03fd06f679dace,
                    "JRC Surface Water" : tile_layer_e5633b4ab72a43bd8988a22f09f12946,
                    "Polygon" : geo_json_ecea21d64ba04fd7aabefdfa94bcb3e2,
                    "US States" : tile_layer_a5e50aff46c948f7b3eba2e8301a9433,
                },
            };
            L.control.layers(
                layer_control_156c6d0f4771479498bee6ab91d49839.base_layers,
                layer_control_156c6d0f4771479498bee6ab91d49839.overlays,
                {"autoZIndex": true, "collapsed": true, "position": "topright"}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
    
            L.control.fullscreen(
                {"forceSeparateButton": false, "position": "topleft", "title": "Full Screen", "titleCancel": "Exit Full Screen"}
            ).addTo(map_5b1400700d1f43c095be29c653d71259);
        
</script>\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
      ],
      "text/plain": [
       "<folium.folium.Map at 0x7faa12c7af98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set visualization parameters.\n",
    "vis_params = {\n",
    "  'min': 0,\n",
    "  'max': 4000,\n",
    "  'palette': ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']}\n",
    "\n",
    "# Create a folium map object.\n",
    "my_map = folium.Map(location=[40.33, -99.42], zoom_start=4, height=500)\n",
    "\n",
    "# Add custom basemaps\n",
    "basemaps['Google Maps'].add_to(my_map)\n",
    "basemaps['Google Satellite Hybrid'].add_to(my_map)\n",
    "\n",
    "# Add the elevation model to the map object.\n",
    "my_map.add_ee_layer(dem.updateMask(dem.gt(0)), vis_params, 'DEM')\n",
    "\n",
    "# Display ee.Image\n",
    "dataset = ee.Image('JRC/GSW1_1/GlobalSurfaceWater')\n",
    "occurrence = dataset.select('occurrence');\n",
    "occurrenceVis = {'min': 0.0, 'max': 100.0, 'palette': ['ffffff', 'ffbbbb', '0000ff']}\n",
    "my_map.add_ee_layer(occurrence, occurrenceVis, 'JRC Surface Water')\n",
    "\n",
    "# Display ee.Geometry\n",
    "holePoly = ee.Geometry.Polygon(coords = [[[-35, -10], [-35, 10], [35, 10], [35, -10], [-35, -10]]],\n",
    "                               proj= 'EPSG:4326',\n",
    "                               geodesic = True,\n",
    "                               maxError= 1.,\n",
    "                               evenOdd = False)\n",
    "my_map.add_ee_layer(holePoly, {}, 'Polygon')\n",
    "\n",
    "# Display ee.FeatureCollection\n",
    "fc = ee.FeatureCollection('TIGER/2018/States')\n",
    "my_map.add_ee_layer(fc, {}, 'US States')\n",
    "\n",
    "# Add a layer control panel to the map.\n",
    "my_map.add_child(folium.LayerControl())\n",
    "plugins.Fullscreen().add_to(my_map)\n",
    "\n",
    "# Display the map.\n",
    "display(my_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chart visualization <a class=\"anchor\" id=\"chart-vis\"></a> \n",
    "\n",
    "\n",
    "Some Earth Engine functions produce tabular data that can be plotted by\n",
    "data visualization packages such as `matplotlib`. The following example\n",
    "demonstrates the display of tabular data from Earth Engine as a scatter\n",
    "plot. See [Charting in Colaboratory](https://colab.sandbox.google.com/notebooks/charts.ipynb)\n",
    "for more information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import the matplotlib.pyplot module.\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Fetch a Landsat image.\n",
    "img = ee.Image('LANDSAT/LT05/C01/T1_SR/LT05_034033_20000913')\n",
    "\n",
    "# Select Red and NIR bands, scale them, and sample 500 points.\n",
    "samp_fc = img.select(['B3','B4']).divide(10000).sample(scale=30, numPixels=500)\n",
    "\n",
    "# Arrange the sample as a list of lists.\n",
    "samp_dict = samp_fc.reduceColumns(ee.Reducer.toList().repeat(2), ['B3', 'B4'])\n",
    "samp_list = ee.List(samp_dict.get('list'))\n",
    "\n",
    "# Save server-side ee.List as a client-side Python list.\n",
    "samp_data = samp_list.getInfo()\n",
    "\n",
    "# Display a scatter plot of Red-NIR sample pairs using matplotlib.\n",
    "plt.scatter(samp_data[0], samp_data[1], alpha=0.2)\n",
    "plt.xlabel('Red', fontsize=12)\n",
    "plt.ylabel('NIR', fontsize=12)\n",
    "plt.show()"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}