mirror of
https://github.com/giswqs/earthengine-py-notebooks.git
synced 2022-05-07 18:24:49 +03:00
Update notebook template
This commit is contained in:
Qiusheng Wu
2
.vscode/settings.json
vendored
2
.vscode/settings.json
vendored
@@ -1,3 +1,3 @@
|
||||
{
|
||||
"python.pythonPath": "/home/qiusheng/.conda/envs/geemap/bin/python"
|
||||
"python.pythonPath": "/home/qiusheng/.conda/envs/gee/bin/python"
|
||||
}
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -154,5 +146,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -160,5 +152,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -148,5 +140,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -200,5 +192,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -163,5 +155,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -263,5 +255,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -179,5 +171,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -1,157 +1,163 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/landsat_cloud_score.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_cloud_score.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_cloud_score.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"# Load a cloudy Landsat scene and display it.\n",
|
||||
"cloudy_scene = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20140926')\n",
|
||||
"Map.centerObject(cloudy_scene)\n",
|
||||
"Map.addLayer(cloudy_scene, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4}, 'TOA', False)\n",
|
||||
"\n",
|
||||
"# Add a cloud score band. It is automatically called 'cloud'.\n",
|
||||
"scored = ee.Algorithms.Landsat.simpleCloudScore(cloudy_scene)\n",
|
||||
"\n",
|
||||
"# Create a mask from the cloud score and combine it with the image mask.\n",
|
||||
"mask = scored.select(['cloud']).lte(20)\n",
|
||||
"\n",
|
||||
"# Apply the mask to the image and display the result.\n",
|
||||
"masked = cloudy_scene.updateMask(mask)\n",
|
||||
"Map.addLayer(masked, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4}, 'masked')\n",
|
||||
"\n",
|
||||
"# Load a Landsat 8 composite and set the SENSOR_ID property.\n",
|
||||
"mosaic = ee.Image(ee.ImageCollection('LANDSAT/LC8_L1T_8DAY_TOA').first()) \\\n",
|
||||
" .set('SENSOR_ID', 'OLI_TIRS')\n",
|
||||
"\n",
|
||||
"# Cloud score the mosaic and display the result.\n",
|
||||
"scored_mosaic = ee.Algorithms.Landsat.simpleCloudScore(mosaic)\n",
|
||||
"Map.addLayer(scored_mosaic, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4},\n",
|
||||
" 'TOA mosaic', False)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"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.1"
|
||||
}
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/landsat_cloud_score.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_cloud_score.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_cloud_score.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"import geemap"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"# Load a cloudy Landsat scene and display it.\n",
|
||||
"cloudy_scene = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20140926')\n",
|
||||
"Map.centerObject(cloudy_scene)\n",
|
||||
"Map.addLayer(cloudy_scene, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4}, 'TOA', False)\n",
|
||||
"\n",
|
||||
"# Add a cloud score band. It is automatically called 'cloud'.\n",
|
||||
"scored = ee.Algorithms.Landsat.simpleCloudScore(cloudy_scene)\n",
|
||||
"\n",
|
||||
"# Create a mask from the cloud score and combine it with the image mask.\n",
|
||||
"mask = scored.select(['cloud']).lte(20)\n",
|
||||
"\n",
|
||||
"# Apply the mask to the image and display the result.\n",
|
||||
"masked = cloudy_scene.updateMask(mask)\n",
|
||||
"Map.addLayer(masked, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4}, 'masked')\n",
|
||||
"\n",
|
||||
"# Load a Landsat 8 composite and set the SENSOR_ID property.\n",
|
||||
"mosaic = ee.Image(ee.ImageCollection('LANDSAT/LC8_L1T_8DAY_TOA').first()) \\\n",
|
||||
" .set('SENSOR_ID', 'OLI_TIRS')\n",
|
||||
"\n",
|
||||
"# Cloud score the mosaic and display the result.\n",
|
||||
"scored_mosaic = ee.Algorithms.Landsat.simpleCloudScore(mosaic)\n",
|
||||
"Map.addLayer(scored_mosaic, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4},\n",
|
||||
" 'TOA mosaic', False)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"hide_input": false,
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.5"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -1,146 +1,152 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/landsat_path_row_limit.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_path_row_limit.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_path_row_limit.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"point = ee.Geometry.Point(-98.7011, 47.2624)\n",
|
||||
"collection = ee.ImageCollection('LANDSAT/LC8_L1T_TOA') \\\n",
|
||||
" .filterBounds(point) \\\n",
|
||||
" .filterDate('2016-01-01', '2018-12-31')\n",
|
||||
"\n",
|
||||
"# print(collection)\n",
|
||||
"\n",
|
||||
"new_col = ee.Algorithms.Landsat.pathRowLimit(collection, 15, 100)\n",
|
||||
"# print(new_col)\n",
|
||||
"\n",
|
||||
"median = new_col.median()\n",
|
||||
"vis = {'bands': ['B5', 'B4', 'B3'], 'max': 0.3}\n",
|
||||
"\n",
|
||||
"Map.setCenter(-98.7011, 47.2624, 10)\n",
|
||||
"Map.addLayer(median, vis, 'Median')\n"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"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.1"
|
||||
}
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/landsat_path_row_limit.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_path_row_limit.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/landsat_path_row_limit.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"import geemap"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"point = ee.Geometry.Point(-98.7011, 47.2624)\n",
|
||||
"collection = ee.ImageCollection('LANDSAT/LC8_L1T_TOA') \\\n",
|
||||
" .filterBounds(point) \\\n",
|
||||
" .filterDate('2016-01-01', '2018-12-31')\n",
|
||||
"\n",
|
||||
"# print(collection)\n",
|
||||
"\n",
|
||||
"new_col = ee.Algorithms.Landsat.pathRowLimit(collection, 15, 100)\n",
|
||||
"# print(new_col)\n",
|
||||
"\n",
|
||||
"median = new_col.median()\n",
|
||||
"vis = {'bands': ['B5', 'B4', 'B3'], 'max': 0.3}\n",
|
||||
"\n",
|
||||
"Map.setCenter(-98.7011, 47.2624, 10)\n",
|
||||
"Map.addLayer(median, vis, 'Median')\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"hide_input": false,
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.5"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -141,5 +133,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -148,5 +140,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -139,5 +131,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -1,159 +1,165 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/ntl_linear_fit.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/ntl_linear_fit.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/ntl_linear_fit.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"# Compute the trend of nighttime lights from DMSP.\n",
|
||||
"\n",
|
||||
"# Add a band containing image date as years since 1990.\n",
|
||||
"def createTimeBand(img):\n",
|
||||
" year = img.date().difference(ee.Date('1990-01-01'), 'year')\n",
|
||||
" return ee.Image(year).float().addBands(img)\n",
|
||||
"\n",
|
||||
"# function createTimeBand(img) {\n",
|
||||
"# year = img.date().difference(ee.Date('1990-01-01'), 'year')\n",
|
||||
"# return ee.Image(year).float().addBands(img)\n",
|
||||
"# }\n",
|
||||
"\n",
|
||||
"# Fit a linear trend to the nighttime lights collection.\n",
|
||||
"collection = ee.ImageCollection('NOAA/DMSP-OLS/CALIBRATED_LIGHTS_V4') \\\n",
|
||||
" .select('avg_vis') \\\n",
|
||||
" .map(createTimeBand)\n",
|
||||
"fit = collection.reduce(ee.Reducer.linearFit())\n",
|
||||
"\n",
|
||||
"# Display a single image\n",
|
||||
"Map.addLayer(ee.Image(collection.select('avg_vis').first()),\n",
|
||||
" {'min': 0, 'max': 63},\n",
|
||||
" 'stable lights first asset')\n",
|
||||
"\n",
|
||||
"# Display trend in red/blue, brightness in green.\n",
|
||||
"Map.setCenter(30, 45, 4)\n",
|
||||
"Map.addLayer(fit,\n",
|
||||
" {'min': 0, 'max': [0.18, 20, -0.18], 'bands': ['scale', 'offset', 'scale']},\n",
|
||||
" 'stable lights trend')\n"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"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.1"
|
||||
}
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"<table class=\"ee-notebook-buttons\" align=\"left\">\n",
|
||||
" <td><a target=\"_blank\" href=\"https://github.com/giswqs/earthengine-py-notebooks/tree/master/Algorithms/ntl_linear_fit.ipynb\"><img width=32px src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /> View source on GitHub</a></td>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://nbviewer.jupyter.org/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/ntl_linear_fit.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>\n",
|
||||
" <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/giswqs/earthengine-py-notebooks/blob/master/Algorithms/ntl_linear_fit.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /> Run in Google Colab</a></td>\n",
|
||||
"</table>"
|
||||
]
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
}
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Installs geemap package\n",
|
||||
"import subprocess\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"import geemap"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Create an interactive map \n",
|
||||
"The default basemap is `Google Maps`. [Additional basemaps](https://github.com/giswqs/geemap/blob/master/geemap/basemaps.py) can be added using the `Map.add_basemap()` function. "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map = geemap.Map(center=[40,-100], zoom=4)\n",
|
||||
"Map"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Add Earth Engine Python script "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Add Earth Engine dataset\n",
|
||||
"# Compute the trend of nighttime lights from DMSP.\n",
|
||||
"\n",
|
||||
"# Add a band containing image date as years since 1990.\n",
|
||||
"def createTimeBand(img):\n",
|
||||
" year = img.date().difference(ee.Date('1990-01-01'), 'year')\n",
|
||||
" return ee.Image(year).float().addBands(img)\n",
|
||||
"\n",
|
||||
"# function createTimeBand(img) {\n",
|
||||
"# year = img.date().difference(ee.Date('1990-01-01'), 'year')\n",
|
||||
"# return ee.Image(year).float().addBands(img)\n",
|
||||
"# }\n",
|
||||
"\n",
|
||||
"# Fit a linear trend to the nighttime lights collection.\n",
|
||||
"collection = ee.ImageCollection('NOAA/DMSP-OLS/CALIBRATED_LIGHTS_V4') \\\n",
|
||||
" .select('avg_vis') \\\n",
|
||||
" .map(createTimeBand)\n",
|
||||
"fit = collection.reduce(ee.Reducer.linearFit())\n",
|
||||
"\n",
|
||||
"# Display a single image\n",
|
||||
"Map.addLayer(ee.Image(collection.select('avg_vis').first()),\n",
|
||||
" {'min': 0, 'max': 63},\n",
|
||||
" 'stable lights first asset')\n",
|
||||
"\n",
|
||||
"# Display trend in red/blue, brightness in green.\n",
|
||||
"Map.setCenter(30, 45, 4)\n",
|
||||
"Map.addLayer(fit,\n",
|
||||
" {'min': 0, 'max': [0.18, 20, -0.18], 'bands': ['scale', 'offset', 'scale']},\n",
|
||||
" 'stable lights trend')\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Display Earth Engine data layers "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"Map.addLayerControl() # This line is not needed for ipyleaflet-based Map.\n",
|
||||
"Map"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"anaconda-cloud": {},
|
||||
"hide_input": false,
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.8.5"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -156,5 +148,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -143,5 +135,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -152,5 +144,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -163,5 +155,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -169,5 +161,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -207,5 +199,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -204,5 +196,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -215,5 +207,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -179,5 +171,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -179,5 +171,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -168,5 +160,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -150,5 +142,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -169,5 +161,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -127,5 +119,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -127,5 +119,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -127,5 +119,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -163,5 +155,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -141,5 +133,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -127,5 +119,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -137,5 +129,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -127,5 +119,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -135,5 +127,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -136,5 +128,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -140,5 +132,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -136,5 +128,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -137,5 +129,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -136,5 +128,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -147,5 +139,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -135,5 +127,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -135,5 +127,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -140,5 +132,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -136,5 +128,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -137,5 +129,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -140,5 +132,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -136,5 +128,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -135,5 +127,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -10,10 +10,8 @@
|
||||
# %%
|
||||
"""
|
||||
## Install Earth Engine API and geemap
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.
|
||||
The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.
|
||||
|
||||
**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving).
|
||||
"""
|
||||
|
||||
# %%
|
||||
@@ -23,24 +21,12 @@ import subprocess
|
||||
try:
|
||||
import geemap
|
||||
except ImportError:
|
||||
print('geemap package not installed. Installing ...')
|
||||
print('Installing geemap ...')
|
||||
subprocess.check_call(["python", '-m', 'pip', 'install', 'geemap'])
|
||||
|
||||
# Checks whether this notebook is running on Google Colab
|
||||
try:
|
||||
import google.colab
|
||||
import geemap.eefolium as geemap
|
||||
except:
|
||||
import geemap
|
||||
|
||||
# Authenticates and initializes Earth Engine
|
||||
# %%
|
||||
import ee
|
||||
|
||||
try:
|
||||
ee.Initialize()
|
||||
except Exception as e:
|
||||
ee.Authenticate()
|
||||
ee.Initialize()
|
||||
import geemap
|
||||
|
||||
# %%
|
||||
"""
|
||||
|
||||
@@ -16,10 +16,8 @@
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Install Earth Engine API and geemap\n",
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://github.com/giswqs/geemap). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet.\n",
|
||||
"\n",
|
||||
"**Important note**: A key difference between folium and ipyleaflet is that ipyleaflet is built upon ipywidgets and allows bidirectional communication between the front-end and the backend enabling the use of the map to capture user input, while folium is meant for displaying static data only ([source](https://blog.jupyter.org/interactive-gis-in-jupyter-with-ipyleaflet-52f9657fa7a)). Note that [Google Colab](https://colab.research.google.com/) currently does not support ipyleaflet ([source](https://github.com/googlecolab/colabtools/issues/60#issuecomment-596225619)). Therefore, if you are using geemap with Google Colab, you should use [`import geemap.eefolium`](https://github.com/giswqs/geemap/blob/master/geemap/eefolium.py). If you are using geemap with [binder](https://mybinder.org/) or a local Jupyter notebook server, you can use [`import geemap`](https://github.com/giswqs/geemap/blob/master/geemap/geemap.py), which provides more functionalities for capturing user input (e.g., mouse-clicking and moving)."
|
||||
"Install the [Earth Engine Python API](https://developers.google.com/earth-engine/python_install) and [geemap](https://geemap.org). The **geemap** Python package is built upon the [ipyleaflet](https://github.com/jupyter-widgets/ipyleaflet) and [folium](https://github.com/python-visualization/folium) packages and implements several methods for interacting with Earth Engine data layers, such as `Map.addLayer()`, `Map.setCenter()`, and `Map.centerObject()`.\n",
|
||||
"The following script checks if the geemap package has been installed. If not, it will install geemap, which automatically installs its [dependencies](https://github.com/giswqs/geemap#dependencies), including earthengine-api, folium, and ipyleaflet."
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -32,24 +30,18 @@
|
||||
"try:\n",
|
||||
" import geemap\n",
|
||||
"except ImportError:\n",
|
||||
" print('geemap package not installed. Installing ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])\n",
|
||||
"\n",
|
||||
"# Checks whether this notebook is running on Google Colab\n",
|
||||
"try:\n",
|
||||
" import google.colab\n",
|
||||
" import geemap.eefolium as geemap\n",
|
||||
"except:\n",
|
||||
" import geemap\n",
|
||||
"\n",
|
||||
"# Authenticates and initializes Earth Engine\n",
|
||||
" print('Installing geemap ...')\n",
|
||||
" subprocess.check_call([\"python\", '-m', 'pip', 'install', 'geemap'])"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"import ee\n",
|
||||
"\n",
|
||||
"try:\n",
|
||||
" ee.Initialize()\n",
|
||||
"except Exception as e:\n",
|
||||
" ee.Authenticate()\n",
|
||||
" ee.Initialize() "
|
||||
"import geemap"
|
||||
],
|
||||
"outputs": [],
|
||||
"execution_count": null
|
||||
@@ -140,5 +132,5 @@
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 1
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user