diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 7f3de708..76ad97ae 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -32,12 +32,6 @@ repos: # - id: doc8 # stages: [pre-commit] - - repo: https://github.com/FHPythonUtils/LicenseCheck - rev: "2023.1.1" - hooks: - - id: licensecheck - stages: [pre-commit] - - repo: https://github.com/codespell-project/codespell rev: v2.2.4 hooks: @@ -45,3 +39,9 @@ repos: stages: [pre-commit] additional_dependencies: - tomli + + - repo: "https://github.com/kynan/nbstripout" + rev: "0.5.0" + hooks: + - id: nbstripout + stages: [pre-commit] diff --git a/docs/_extension/api_admonition.py b/docs/_extension/api_admonition.py new file mode 100644 index 00000000..4b6c69dd --- /dev/null +++ b/docs/_extension/api_admonition.py @@ -0,0 +1,74 @@ +"""A directive to generate an API admonition.""" + +from typing import Any, Dict + +from docutils import nodes +from docutils.parsers.rst import directives +from docutils.parsers.rst.directives.admonitions import BaseAdmonition +from sphinx.application import Sphinx +from sphinx.util import logging +from sphinx.util.docutils import SphinxDirective +from sphinx.writers.html5 import HTML5Translator + +logger = logging.getLogger(__name__) + + +class api_node(nodes.Admonition, nodes.Element): + pass + + +def visit_api_node(self: HTML5Translator, node: api_node) -> None: + self.visit_admonition(node) + + +def depart_api_node(self: HTML5Translator, node: api_node) -> None: + self.depart_admonition(node) + + +class APIAdmonitionDirective(BaseAdmonition, SphinxDirective): + """An API entry, displayed (if configured) in the form of an admonition.""" + + node_class = api_node + has_content = True + required_arguments = 0 + optional_arguments = 0 + final_argument_whitespace = False + option_spec = { + "class": directives.class_option, + "name": directives.unchanged, + } + + def run(self) -> list[nodes.Node]: + if not self.options.get("class"): + self.options["class"] = ["admonition-api"] + + (api,) = super().run() + if isinstance(api, nodes.system_message): + return [api] + elif isinstance(api, api_node): + api.insert(0, nodes.title(text="See API")) + api["docname"] = self.env.docname + self.add_name(api) + self.set_source_info(api) + self.state.document.note_explicit_target(api) + return [api] + else: + raise RuntimeError # never reached here + + +def setup(app: Sphinx) -> Dict[str, Any]: + """Add custom configuration to sphinx app. + + Args: + app: the Sphinx application + + Returns: + the 2 parallel parameters set to ``True``. + """ + app.add_directive("api", APIAdmonitionDirective) + app.add_node(api_node, html=(visit_api_node, depart_api_node)) + + return { + "parallel_read_safe": True, + "parallel_write_safe": True, + } diff --git a/docs/_static/custom.css b/docs/_static/custom.css index 0af9db66..07764445 100644 --- a/docs/_static/custom.css +++ b/docs/_static/custom.css @@ -4,3 +4,7 @@ div.highlight-console pre span.go::before { margin-right: 10px; margin-left: 5px; } + +div.admonition.admonition-api > .admonition-title::after { + content: "\f121"; /* the fa-code icon */ +} diff --git a/docs/conf.py b/docs/conf.py index 047afd4d..507cb4ea 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -7,12 +7,11 @@ # -- Path setup ---------------------------------------------------------------- import os -import re import sys from datetime import datetime from pathlib import Path -import ee +import pytest_gee # add . to sys to import local extensions sys.path.append(str(Path(".").resolve())) @@ -29,12 +28,14 @@ "sphinx.ext.viewcode", "sphinx.ext.intersphinx", "sphinx.ext.autosectionlabel", + "sphinxcontrib.icon", "sphinx_design", "sphinx_copybutton", "autoapi.extension", "jupyter_sphinx", - "nbsphinx", + "myst_nb", "_extension.docstring", + "_extension.api_admonition", ] exclude_patterns = ["**.ipynb_checkpoints"] @@ -123,41 +124,18 @@ # -- options for the autolabel extension --------------------------------------- autosectionlabel_prefix_document = True -# -- options for nbsphinx ------------------------------------------------------ -nbsphinx_execute = "never" +# -- options for myst-nb ------------------------------------------------------ +nb_execution_mode = "force" # -- Script to authenticate to Earthengine using a token ----------------------- def gee_configure() -> None: - """Initialize earth engine according to the environment. - - It will use the creddential file if the EARTHENGINE_TOKEN env variable exist. - Otherwise it use the simple Initialize command (asking the user to register if necessary). - """ - # only do the initialization if the credential are missing - if False: - # if not ee.data._credentials: - - # if the credentials token is asved in the environment use it - if "EARTHENGINE_TOKEN" in os.environ: - - # get the token from environment variable - ee_token = os.environ["EARTHENGINE_TOKEN"] - - # as long as RDT quote the token, we need to remove the quotes before writing - # the string to the file - pattern = r"^'[^']*'$" - if re.match(pattern, ee_token) is not None: - ee_token = ee_token[1:-1] - - # write the token to the appropriate folder - credential_folder_path = Path.home() / ".config" / "earthengine" - credential_folder_path.mkdir(parents=True, exist_ok=True) - credential_file_path = credential_folder_path / "credentials" - credential_file_path.write_text(ee_token) - - # if the user is in local development the authentication should - # already be available - ee.Initialize() + """Initialize earth engine according to the environment.""" + if "EARTHENGINE_SERVICE_ACCOUNT" in os.environ: + pytest_gee.init_ee_from_service_account() + elif "EARTHENGINE_PROJECT" in os.environ: + pytest_gee.init_ee_from_token() + else: + raise ValueError("Cannot authenticate with Earth Engine.") gee_configure() diff --git a/docs/example/asset.ipynb b/docs/example/asset.ipynb deleted file mode 100644 index 25f999c6..00000000 --- a/docs/example/asset.ipynb +++ /dev/null @@ -1,132 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Manage Assets as ``Path`` objects" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee_community/geetools/blob/main/docs/example/asset.ipynb)\n", - "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee_community/geetools/blob/main/docs/example/asset.ipynb)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up environment\n", - "\n", - "Install all the required libs if necessary and perform the import statements upstream." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if installation of libs is necessary\n", - "# !pip install earthengine-api geetools" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import ee\n", - "import geetools #noqa: F401" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if authetication to GEE is needed\n", - "# ee.Authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if initialization is required\n", - "# ee.Initialize()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The `Asset` object\n", - "\n", - "In Google Earth Engine API, users are working with Assets. An asset is a filelike object that englobes a wide variety of types: IMAGE, IMAGE_COLLECTION, FOLDER, TABLE, FEATURE_COLLECTION, etc.\n", - "\n", - "They are identified by a unique ID, which is a string that looks like this: `projects/username/assets/foo`. They can be modified using the `ee.data` module. This module has been proven complicated when dealing with basic file manipulation operation such as listing, moving, copying, etc.\n", - "\n", - "`geetools` provides a simple way to manage assets using the `Asset` object. This object is a subclass of the `pathlib.Path` object, which is a powerful way to manage file paths in Python. Most of the methods and properties are overwritten to work with the Google Earth Engine API." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# let's create a folder asset from the root folder\n", - "folder = ee.Asset(\"~/test_folder/subfolder\").expanduser()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "then many operations can be performed on it" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# create the actual asset object\n", - "folder.mkdir(parents=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# see the parents of the asset\n", - "folder.parents" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To get more informations on the `Asset` object, it's properties and methods, you can refer to our [API documentation](https://geetools.readthedocs.io/en/latest/autoapi/geetools/Asset/index.html)." - ] - } - ], - "metadata": { - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/example/index.rst b/docs/example/index.rst deleted file mode 100644 index 9891cc57..00000000 --- a/docs/example/index.rst +++ /dev/null @@ -1,44 +0,0 @@ -Examples -======== - -Overview --------- - -This section gathered may real lif example of the Lib usage gathered by the community. -If you think your workflow should be shared please open a PR and follow the contribution guildelines shared in the next section. - -.. warning:: - - The example gallery is a work in progress as the library was recently refactored. - All contributions are welcolmed! - -Add a new example ------------------ - -.. image:: /_static/we-need-you.jpg - :alt: We need you! - :align: center - -Currently most of the examples built by `@Rodrigo `__ are still using the old implementation of the library. -They should be transformed into modern example and moved from the old `notebook `__ folder to the new `example `__ one to be displayed in our doc. - -The examples are regular notebook files that are interpreted by the nbsphinx lib and displayed in the doc, clicking on the :guilabel:`open in colab` button will open a colab notebook with the code ready to be executed and the :guilabel:`view source` will bring you back to github. - -To add a new example, you can use the `example template `__ and replace things with your code. - -Adapt the code of the 2 first buttons to your file so users can lunch it in collab and view the source in github. - -.. code-block:: md - - [![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee_community/geetools/blob/main/docs/example/template.ipynb) - [![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee_community/gee_tools/blob/main/docs/example/template.ipynb) - - -Then you can open a PR with the new file and it will be reviewed and merged. - -.. toctree:: - :hidden: - - template - asset - plot_featureCollection \ No newline at end of file diff --git a/docs/example/plot_featureCollection.ipynb b/docs/example/plot_featureCollection.ipynb deleted file mode 100644 index 224984c9..00000000 --- a/docs/example/plot_featureCollection.ipynb +++ /dev/null @@ -1,550 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plot `ee.FeatureCollection` objects using matplotlib\n", - "\n", - "The `geetools` extension contains a set of functions for rendering charts from `ee.FeatureCollection` objects. The choice of function determines the arrangement of data in the chart, i.e., what defines x- and y-axis values and what defines the series. Use the following function descriptions and examples to determine the best function and chart type for your purpose." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee-community/geetools/blob/main/docs/example/plot_featureCollection.ipynb)\n", - "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee-community/geetools/blob/main/docs/example/plot_featureCollection.ipynb)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up environment\n", - "\n", - "Install all the required libs if necessary and perform the import statements upstream." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if installation of libs is necessary\n", - "# !pip install earthengine-api geetools\n", - "import ee, geetools, pytest_gee\n", - "\n", - "pytest_gee.init_ee_from_service_account()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib import pyplot as plt\n", - "\n", - "import ee\n", - "import geetools #noqa: F401" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if authetication to GEE is needed\n", - "# ee.Authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# uncomment if initialization is required\n", - "# ee.Initialize()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example data\n", - "\n", - "The following examples rely on a FeatureCollection composed of three ecoregion features with properties that describe climate normals." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Import the example feature collection.\n", - "ecoregions = ee.FeatureCollection('projects/google/charts_feature_example')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ee.FeatureCollection.geetools.plot_by_features\n", - "\n", - "### Column chart\n", - "\n", - "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by adjacent columns defined by a list of property names whose values are plotted along the y-axis." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'apr': {'Desert': 14.251640262603761, 'Forest': 7.120137078551952, 'Grassland': 7.7213063400332675}, 'aug': {'Desert': 23.845259066990447, 'Forest': 17.919982716498247, 'Grassland': 21.848346125906527}, 'dec': {'Desert': 5.641385506221227, 'Forest': 2.317885516018703, 'Grassland': -3.4267057673087833}, 'feb': {'Desert': 7.6450114270619, 'Forest': 3.609074035652296, 'Grassland': -1.9902201443796765}, 'jan': {'Desert': 5.791035977772305, 'Forest': 2.792466754200815, 'Grassland': -3.7566084167809777}, 'jul': {'Desert': 25.06657654081073, 'Forest': 17.850177143725396, 'Grassland': 22.753059371178896}, 'jun': {'Desert': 23.790505815233505, 'Forest': 13.776134290000945, 'Grassland': 19.033557568368703}, 'mar': {'Desert': 10.454658155441285, 'Forest': 5.032931559387294, 'Grassland': 2.5701463153291244}, 'may': {'Desert': 19.0328149005345, 'Forest': 10.395376066595201, 'Grassland': 13.643875216053496}, 'nov': {'Desert': 9.84932084628514, 'Forest': 4.784705665376451, 'Grassland': 2.0219183634764555}, 'oct': {'Desert': 15.997987973349439, 'Forest': 10.081708544515559, 'Grassland': 9.263020804676962}, 'sep': {'Desert': 21.454794812883655, 'Forest': 15.206573457096727, 'Grassland': 16.401770091220747}}\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize the plot with the ecoregions data\n", - "ecoregions.geetools.plot_by_features(\n", - " type = \"bar\",\n", - " featureId = \"label\",\n", - " properties = ['01_tmean', '02_tmean', '03_tmean', '04_tmean', '05_tmean', '06_tmean', '07_tmean', '08_tmean', '09_tmean', '10_tmean', '11_tmean', '12_tmean'],\n", - " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " colors = ['#604791', '#1d6b99', '#39a8a7', '#0f8755', '#76b349', '#f0af07', '#e37d05', '#cf513e', '#96356f', '#724173', '#9c4f97', '#696969'],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Temperature by Ecoregion\")\n", - "ax.set_xlabel(\"Ecoregion\")\n", - "ax.set_ylabel(\"Temperature (°C)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Stacked column chart\n", - "\n", - "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by stacked columns defined by a list of property names whose values are plotted along the y-axis as the cumulative series sum." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ecoregions.geetools.plot_by_features(\n", - " type = \"stacked\",\n", - " featureId = \"label\",\n", - " properties = ['01_ppt', '02_ppt', '03_ppt', '04_ppt', '05_ppt', '06_ppt', '07_ppt', '08_ppt', '09_ppt', '10_ppt', '11_ppt', '12_ppt'],\n", - " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " colors = ['#604791', '#1d6b99', '#39a8a7', '#0f8755', '#76b349', '#f0af07', '#e37d05', '#cf513e', '#96356f', '#724173', '#9c4f97', '#696969'],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", - "ax.set_xlabel(\"Ecoregion\")\n", - "ax.set_ylabel(\"Precipitation (mm)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Scatter chart\n", - "\n", - "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by points defined by a list of property names whose values are plotted along the y-axis." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApcAAAHHCAYAAADqCnP7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbfUlEQVR4nO3deVhUZf8G8HtmWAaQRZA1CVBSQXHBLcQlFRV3FDOtRNS0Uiwjy+UtkSyXUjN3bVErTSu1tHJXcsNdXF5wDTGVTREQEYSZ5/cHL/NzGFBGzzAs9+e65tJ5znPO+c4My80553mOTAghQEREREQkAbmxCyAiIiKi6oPhkoiIiIgkw3BJRERERJJhuCQiIiIiyTBcEhEREZFkGC6JiIiISDIMl0REREQkGYZLIiIiIpIMwyURERERSYbhkqiamz59OmQyGW7fvv3Evp6enggPDzd8UUawevVqyGQyXLt2Te91Y2JiIJPJEBMTI3ldpSn+zCratWvXIJPJMHfu3Arfd3VjrM+QqDJguKQnWrp0KWQyGdq2bWvsUiodT09PyGQyBAUFlbr866+/hkwmg0wmw4kTJwxay8yZM/Hbb78ZdB/6KA4qxQ+FQoHnn38eAwYMQFxcnLHLe2br1q3DggULnnr93NxcTJ8+vcICa2VSHPTLehw5csTYJRLRMzAxdgFU+a1duxaenp44duwYrly5Am9vb2OXVKkolUrs27cPKSkpcHFx0Vq2du1aKJVK5OXlGbyOmTNnYtCgQQgJCTH4vvQxdOhQ9OrVCyqVCgkJCVi2bBm2bduGI0eOoHnz5hVWx7BhwzBkyBCYm5vrvW7Hjh3x4MEDmJmZadrWrVuH8+fPY8KECU9VT25uLqKjowEAL730ktayjz76CJMnT36q7VYln3zyCby8vHTaq8PPmJryGRKVhuGSHisxMRGHDx/Gpk2b8Oabb2Lt2rWIioqq0BrUajUePnwIpVJZofstr8DAQBw/fhwbNmzAu+++q2m/ceMGDhw4gAEDBmDjxo1GrNC4/P398frrr2ueBwYGol+/fli2bBlWrFhR6jr379+HlZWVpHUoFAooFIqnWlcul1fo15+JiQlMTKr/j+eePXuiVatWRtu/EAJ5eXmwsLCQfNs15TMkKg1Pi9NjrV27FrVr10bv3r0xaNAgrF27VrOsoKAA9vb2GDFihM562dnZUCqVmDhxoqYtPz8fUVFR8Pb2hrm5Odzd3fHhhx8iPz9fa12ZTIaIiAisXbsWjRs3hrm5ObZv3w4AmDt3Ltq1awcHBwdYWFigZcuW+PXXX3X2/+DBA7zzzjuoU6cOrK2t0a9fP9y8eRMymQzTp0/X6nvz5k2MHDkSzs7OMDc3R+PGjfHdd9+V+z1SKpUYOHAg1q1bp9X+008/oXbt2ujRo0ep6+3duxcdOnSAlZUV7Ozs0L9/fyQkJGj1Kb5u68qVKwgPD4ednR1sbW0xYsQI5Obmar1n9+/fx5o1azSnFkteO5mZmfnYbZT0zz//QCaT4csvv9RZdvjwYchkMvz0009Pent0dOnSBUDRHy7A/58i/fvvvzF27Fg4OTmhbt26mv7btm3TvE/W1tbo3bs3/vvf/+ps98KFCxg8eDAcHR1hYWGBhg0b4j//+Y9meWnXXHp6eqJPnz7YuXMnmjdvDqVSCV9fX2zatElr2yWvuXzppZfw559/IikpSfN+e3p6AgAePnyIadOmoWXLlrC1tYWVlRU6dOiAffv2abZ37do1ODo6AgCio6M12yj+2izter3CwkLMmDED9evXh7m5OTw9PTF16lSd75/i13Tw4EG0adMGSqUS9erVw/fff/+kj0bLl19+CQ8PD1hYWKBTp044f/68ZtmqVasgk8lw+vRpnfVmzpwJhUKBmzdv6rW/sqjVanz11Vfw8/ODUqmEo6MjgoODtS4z0fe92bFjB1q1agULCwvNHziZmZmYMGEC3N3dYW5uDm9vb8yZMwdqtVprG3fu3MGwYcNgY2MDOzs7DB8+HGfOnIFMJsPq1as1/SrDZ0hkNILoMRo1aiRGjRolhBBi//79AoA4duyYZvnIkSOFnZ2dyM/P11pvzZo1AoA4fvy4EEIIlUolunfvLiwtLcWECRPEihUrREREhDAxMRH9+/fXWheA8PHxEY6OjiI6OlosWbJEnD59WgghRN26dcXYsWPF4sWLxfz580WbNm0EAPHHH39obWPw4MECgBg2bJhYsmSJGDx4sGjWrJkAIKKiojT9UlJSRN26dYW7u7v45JNPxLJly0S/fv0EAPHll18+8f3x8PAQvXv3Fjt37hQAxJUrVzTLmjdvLt58802xatUqrfdCCCF27dolTExMRIMGDcTnn38uoqOjRZ06dUTt2rVFYmKipl9UVJQAIFq0aCEGDhwoli5dKt544w0BQHz44Yeafj/88IMwNzcXHTp0ED/88IP44YcfxOHDh/XaRvHrGT58uOZ5YGCgaNmypc7rHjt2rLC2thb3798v871JTEwUAMQXX3yh1X7mzBkBQAwZMkQIITTvj6+vr+jUqZNYtGiRmD17thBCiO+//17IZDIRHBwsFi1aJObMmSM8PT2FnZ2d1vt05swZYWNjIxwcHMSUKVPEihUrxIcffij8/Pw0fYr38+h6Hh4eokGDBsLOzk5MnjxZzJ8/X/j5+Qm5XC527typ6bdv3z4BQOzbt08IIcTOnTtF8+bNRZ06dTTv9+bNm4UQQqSnpwtXV1cRGRkpli1bJj7//HPRsGFDYWpqqvk6zsnJEcuWLRMAxIABAzTbOHPmjNZn9qjhw4cLAGLQoEFiyZIlIiwsTAAQISEhWv08PDxEw4YNhbOzs5g6dapYvHix8Pf3FzKZTJw/f77Mz+vRz8zPz094enqKOXPmiOjoaGFvby8cHR1FSkqKEEKI7OxsYWFhId5//32dbfj6+oouXbo8dj/Fn8Xu3btFenq61uP27dtafcPDwwUA0bNnT7FgwQIxd+5c0b9/f7Fo0aKnem+8vb1F7dq1xeTJk8Xy5cvFvn37xP3790XTpk2Fg4ODmDp1qli+fLkICwsTMplMvPvuu5r1VSqVCAgIEAqFQkRERIjFixeLbt26aX62rFq1StPXWJ8hUWXAcEllOnHihAAgdu3aJYQQQq1Wi7p162r9sN2xY4cAILZu3aq1bq9evUS9evU0z3/44Qchl8vFgQMHtPotX75cABCHDh3StAEQcrlc/Pe//9WpKTc3V+v5w4cPRZMmTbR+mZ08eVIAEBMmTNDqW/xL6tFwOWrUKOHq6qrzC23IkCHC1tZWZ38lFYfLwsJC4eLiImbMmCGEECI+Pl4AEH///Xep4bJ58+bCyclJ3LlzR9N25swZIZfLRVhYmKat+BfUyJEjtfY7YMAA4eDgoNVmZWWlFQyfZhslw+WKFSsEAJGQkKBpe/jwoahTp06p+3pUcVCJjo4W6enpIiUlRcTExIgWLVoIAGLjxo1CiP8PGu3btxeFhYWa9e/duyfs7OzE6NGjtbabkpIibG1ttdo7duworK2tRVJSklZftVqt+X9Z4fLRWoQQIisrS7i6uooWLVpo2kqGSyGE6N27t/Dw8NB53YWFhTp/bN29e1c4OztrfQbp6ek6X4/FSgaTuLg4AUC88cYbWv0mTpwoAIi9e/fqvKb9+/dr2tLS0oS5uXmpYfBRxZ+ZhYWFuHHjhqb96NGjAoB47733NG1Dhw4Vbm5uQqVSadpOnTqlE7JKU/xZlPYwNzfX9Nu7d68AIN555x2dbRR/tk/z3mzfvl2r74wZM4SVlZW4dOmSVvvkyZOFQqEQ169fF0IIsXHjRgFALFiwQNNHpVKJLl26PDFcVtRnSFQZ8LQ4lWnt2rVwdnZG586dARSden3llVewfv16qFQqAEWnOOvUqYMNGzZo1rt79y527dqFV155RdP2yy+/wMfHB40aNcLt27c1j+JTpI+eMgSATp06wdfXV6emR6+Nunv3LrKystChQwecOnVK0158Cn3s2LFa644fP17ruRACGzduRN++fSGE0KqrR48eyMrK0tru4ygUCgwePFhzmnjt2rVwd3dHhw4ddPomJycjLi4O4eHhsLe317Q3bdoU3bp1w19//aWzzltvvaX1vEOHDrhz5w6ys7PLVd/TbmPw4MFQKpVal0Ps2LEDt2/f1rqO8nGioqLg6OgIFxcXvPTSS7h69SrmzJmDgQMHavUbPXq01jWRu3btQmZmJoYOHar12SgUCrRt21bzNZOeno79+/dj5MiReP7557W2WZ6pYNzc3DBgwADNcxsbG4SFheH06dNISUkp12t8lEKh0Az8UavVyMjIQGFhIVq1alXur6eSir8mIiMjtdrff/99AMCff/6p1e7r66v1tefo6IiGDRvin3/+Kdf+QkJC8Nxzz2met2nTBm3bttX62gwLC8OtW7e0vnfXrl0LCwsLhIaGlms/S5Yswa5du7Qe27Zt0yzfuHEjZDJZqdd5F3+2+r43Xl5eOpeq/PLLL+jQoQNq166t9bUWFBQElUqF/fv3Ayj62WJqaorRo0dr1pXL5Rg3btwTX2tFf4ZExsSrjalUKpUK69evR+fOnTXXxgFA27ZtMW/ePOzZswfdu3eHiYkJQkNDsW7dOuTn58Pc3BybNm1CQUGBVri8fPkyEhISNNeZlZSWlqb1vLQRpADwxx9/4NNPP0VcXJzWdUqPhoikpCTI5XKdbZQcgZqeno7MzEysXLkSK1euLFddj/Pqq69i4cKFOHPmDNatW4chQ4aUGm6SkpIAAA0bNtRZ5uPjgx07dugMaCkZmmrXrg2gKGDb2NiUq76n2YadnR369u2LdevWYcaMGQCKAsRzzz2n+cPgScaMGYOXX34ZcrkcdnZ2mutoSyr5eV2+fBkAytxPcc3Fv2ybNGlSrnpK8vb21vmcGjRoAKDo2siSMwCUx5o1azBv3jxcuHABBQUFmvayvq6fpPhruuTXsIuLC+zs7DRfU8VKftZA0ed99+7dcu3vhRde0Glr0KABfv75Z83zbt26wdXVFWvXrkXXrl2hVqvx008/oX///rC2ti7Xftq0afPYAT1Xr16Fm5ub1h9hJen73pT2GVy+fBlnz5594s+npKQkuLq6wtLSUmt5eUa3V/RnSGRMDJdUqr179yI5ORnr16/H+vXrdZavXbsW3bt3BwAMGTIEK1aswLZt2xASEoKff/4ZjRo1QrNmzTT91Wo1/Pz8MH/+/FL35+7urvW8tNGbBw4cQL9+/dCxY0csXboUrq6uMDU1xapVq3QG05RH8YX6r7/+OoYPH15qn6ZNm5Z7e23btkX9+vUxYcIEJCYm4tVXX9W7prKUNcpZCGHwbYSFheGXX37B4cOH4efnhy1btmDs2LGQy8t34uOFF14ocx7QR5X8zIs/nx9++KHUgFdZR+L++OOPCA8PR0hICD744AM4OTlBoVBg1qxZuHr16jNtu7yTckvx9VKefbz66qv4+uuvsXTpUhw6dAi3bt0q9xFtqZX3vSntZ4tarUa3bt3w4YcflrpO8R8bUqhMnyGRoVTOn85kdGvXroWTkxOWLFmis2zTpk3YvHkzli9fDgsLC3Ts2BGurq7YsGED2rdvj71792qN0gWA+vXr48yZM+jatetT37Vi48aNUCqV2LFjh9aRr1WrVmn18/DwgFqtRmJiotYRmCtXrmj1c3R0hLW1NVQqVbnCT3kMHToUn376KXx8fMqcw9HDwwMAcPHiRZ1lFy5cQJ06dZ5qGh5D3Q0kODgYjo6OWLt2Ldq2bYvc3FwMGzbMIPt6VP369QEATk5Oj/186tWrBwBao5n1ceXKFQghtN6/S5cuAYBmBHhpynq/f/31V9SrVw+bNm3S6lPy1K4+n1fx1/Tly5fh4+OjaU9NTUVmZqbma0oqxUeNH3Xp0iWd9yMsLAzz5s3D1q1bsW3bNjg6OpY5O8LTqF+/Pnbs2IGMjIwyj15K8d7Ur18fOTk5T/w54OHhgX379iE3N1fr6GXJny2GqpOoquA1l6TjwYMH2LRpE/r06YNBgwbpPCIiInDv3j1s2bIFQNE1R4MGDcLWrVvxww8/oLCwUOuUOFB07d7Nmzfx9ddfl7q/+/fvP7EuhUIBmUymud4TKDptWfKuNMW/3JYuXarVvmjRIp3thYaGYuPGjaUGk/T09CfWVNIbb7yBqKgozJs3r8w+rq6uaN68OdasWYPMzExN+/nz57Fz50706tVL7/0CgJWVldb2pGJiYoKhQ4fi559/xurVq+Hn56fXEd2n1aNHD9jY2GDmzJlap5aLFX8+jo6O6NixI7777jtcv35dq095jvLcunULmzdv1jzPzs7G999/j+bNmz/2lLiVlRWysrJ02ouPOD2676NHjyI2NlarX3E4Kc9nVvw1UfKOQMVnAnr37v3Ebejjt99+05pK6NixYzh69Ch69uyp1a9p06Zo2rQpvvnmG2zcuBFDhgyR9IhyaGgohBCayeYfVfz+SvHeDB48GLGxsdixY4fOsszMTBQWFgIo+posKCjQ+jmmVqtL/SO8pIr+DImMiUcuSceWLVtw79499OvXr9TlL774ouZIVnGIfOWVV7Bo0SJERUXBz89P6y9zoOjuKD///DPeeust7Nu3D4GBgVCpVLhw4QJ+/vlnzbxzj9O7d2/Mnz8fwcHBePXVV5GWloYlS5bA29sbZ8+e1fRr2bIlQkNDsWDBAty5cwcvvvgi/v77b83RqEePGM2ePRv79u1D27ZtMXr0aPj6+iIjIwOnTp3C7t27kZGRodd75+HhoTOPZmm++OIL9OzZEwEBARg1ahQePHiARYsWwdbWtlzrl6Zly5bYvXs35s+fDzc3N3h5eUl2y86wsDAsXLgQ+/btw5w5cyTZ5pPY2Nhg2bJlGDZsGPz9/TFkyBA4Ojri+vXr+PPPPxEYGIjFixcDABYuXIj27dvD398fY8aMgZeXF65du4Y///zzibeabNCgAUaNGoXjx4/D2dkZ3333HVJTU3WOiJfUsmVLbNiwAZGRkWjdujVq1aqFvn37ok+fPti0aRMGDBiA3r17IzExEcuXL4evry9ycnI061tYWMDX1xcbNmxAgwYNYG9vjyZNmpR67WizZs0wfPhwrFy5EpmZmejUqROOHTuGNWvWICQkRDPoTire3t5o37493n77beTn52PBggVwcHAo9bRxWFiYZj5bfU+Jb9u2DRcuXNBpb9euHerVq4fOnTtj2LBhWLhwIS5fvozg4GCo1WocOHAAnTt3RkREhCTvzQcffIAtW7agT58+CA8PR8uWLXH//n2cO3cOv/76K65du4Y6deogJCQEbdq0wfvvv48rV66gUaNG2LJli+bnxOOORlf0Z0hkVEYapU6VWN++fYVSqXzsHIbh4eHC1NRUM4WPWq0W7u7uAoD49NNPS13n4cOHYs6cOaJx48bC3Nxc1K5dW7Rs2VJER0eLrKwsTT8AYty4caVu49tvvxUvvPCCMDc3F40aNRKrVq0qdT65+/fvi3Hjxgl7e3tRq1YtERISIi5evCgAaOZQLJaamirGjRsn3N3dhampqXBxcRFdu3YVK1eufOJ7VTwV0eOUNhWREELs3r1bBAYGCgsLC2FjYyP69u0r4uPjtfoUv7b09PRSt/notDoXLlwQHTt2FBYWFgKAZqogfbZRciqiRzVu3FjI5XKtKWoep6x5Lksq6/0ptm/fPtGjRw9ha2srlEqlqF+/vggPDxcnTpzQ6nf+/HkxYMAAYWdnJ5RKpWjYsKH4+OOPn/h6e/fuLXbs2CGaNm2q+br65ZdfdGpAiamIcnJyxKuvvirs7OwEAM20RGq1WsycOVN4eHgIc3Nz0aJFC/HHH3+I4cOH60xddPjwYdGyZUthZmamNS1RaV/TBQUFIjo6Wnh5eQlTU1Ph7u4upkyZIvLy8rT6lfU12alTJ9GpU6dS3+Nij35m8+bNE+7u7pr5U4vn4CwpOTlZKBQK0aBBg8du+1GPm4oIJab0KSwsFF988YVo1KiRMDMzE46OjqJnz57i5MmTkr03QhRNfTVlyhTh7e0tzMzMRJ06dUS7du3E3LlzxcOHDzX90tPTxauvviqsra2Fra2tCA8PF4cOHRIAxPr16zX9jPUZElUGMiF4dTDVDHFxcWjRogV+/PFHvPbaa8Yup8pp0aIF7O3tsWfPHmOXIhlPT080adIEf/zxh7FLqbJu374NV1dXTJs2DR9//LGxyzGK3377DQMGDMDBgwcRGBho7HKIjI7XXFK19ODBA522BQsWQC6Xo2PHjkaoqGo7ceIE4uLiEBYWZuxSqJJZvXo1VCpVhQzyqgxK/mxRqVRYtGgRbGxs4O/vb6SqiCoXXnNJ1dLnn3+OkydPonPnzjAxMcG2bduwbds2jBkzRmfaIyrb+fPncfLkScybNw+urq46A7Wo5tq7dy/i4+Px2WefISQk5LEj66uT8ePH48GDBwgICEB+fj42bdqEw4cPY+bMmaVOc0RUEzFcUrXUrl077Nq1CzNmzEBOTg6ef/55TJ8+XWeKJHq8X3/9FZ988gkaNmyIn376CUql0tglUSXxySef4PDhwwgMDNSZiaE669KlC+bNm4c//vgDeXl58Pb2xqJFixAREWHs0ogqDV5zSURERESS4TWXRERERCQZhksiIiIikgzDJYru9JCdnc17thIRERE9I4ZLAPfu3YOtrS3u3btn7FKIiIiIqjSGSyIiIiKSDMMlEREREUmG4ZKIiIiIJMNwSURERESSYbgkIiIiIsnw9o9ERERU46nVajx8+NDYZVRKpqamUCgU5e7PcElEREQ12sOHD5GYmAi1Wm3sUiotOzs7uLi4QCaTPbEvwyURERHVWEIIJCcnQ6FQwN3dHXI5rxh8lBACubm5SEtLAwC4uro+cR2GSyIiIqqxCgsLkZubCzc3N1haWhq7nErJwsICAJCWlgYnJ6cnniJnPCciIqIaS6VSAQDMzMyMXEnlVhy8CwoKntiX4ZKIiIhqvPJcS1iT6fP+8LQ4EVVbKrXAscQMpN3Lg5O1Em287KGQ8xcIEZEhMVwSUbW0/XwyorfGIzkrT9PmaqtEVF9fBDd58gXpRESVXXh4ODIzM/Hbb78ZuxQtDJdEVO1sP5+Mt388BVGiPSUrD2//eArLXvdnwCSiKu+rr76CECV/0hkfr7kkompFpRaI3hqvEywBaNqit8ZDpa58P5CJqOpSqQVir97B73E3EXv1ToX8jLG1tYWdnZ3B96MvhksiqlaOJWZonQovSQBIzsrDscSMiiuKiKq17eeT0X7OXgz9+gjeXR+HoV8fQfs5e7H9fLJB9xseHo6QkJCiGrZvR/v27WFnZwcHBwf06dMHV69e1fS9du0aZDIZNm3ahM6dO8PS0hLNmjVDbGys5HUxXBJRtZJ2r+xg+TT9iIgep/gynJJ/1BZfhmPogFns/v37iIyMxIkTJ7Bnzx7I5XIMGDBA565D//nPfzBx4kTExcWhQYMGGDp0KAoLCyWthddcElG14mStlLQfEVFZnnQZjgxFl+F083Ux+EwVoaGhWs+/++47ODo6Ij4+Hk2aNNG0T5w4Eb179wYAREdHo3Hjxrhy5QoaNWokWS08cklE1UobL3u42ipR1o9xGYpGjbfxsq/IsoioGqpMl+FcvnwZQ4cORb169WBjYwNPT08AwPXr17X6NW3aVPP/4ls5Ft/aUSoMl0RUrSjkMkT19QUAnYBZ/Dyqry/nuySiZ1aZLsPp27cvMjIy8PXXX+Po0aM4evQoAODhw4da/UxNTTX/L54YveSp82fFcElE1U5wE1cse90fLrbap75dbJWchoiIJFNZLsO5c+cOLl68iI8++ghdu3aFj48P7t69a9B9Pg6vuSSiaim4iSu6+brwDj1EZDDFl+GkZOWVet2lDEV/1Br6MpzatWvDwcEBK1euhKurK65fv47JkycbdJ+PwyOXRFRtKeQyBNR3QP/mzyGgvgODJRFJqrJchiOXy7F+/XqcPHkSTZo0wXvvvYcvvvjCoPt8HB65JCIiInpKxZfhlLzdrEsF3G42Pz8ftWrVAgAEBQUhPj5ea/mjd+/x9PTUuZuPnZ2dQe7ww3BJRERE9Awq+jKcwsJCXLp0CbGxsXjzzTcNso9nwXBJRERE9IyKL8OpCOfPn0e7du3QuXNnvPXWWxWyT30wXBIRERFVIc2bN0dubq6xyygTB/QQERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElERERUBYWHhyMkJMTYZejgPJdEREREVdBXX31lkNs3PiuGSyIiIqJnpVYBSYeBnFSgljPg0Q6QKwy6S1tbW4Nu/2nxtDgRERHRs4jfAixoAqzpA2wcVfTvgiZF7Qb06GlxT09PLFiwQGt58+bNMX36dM1zmUyGb775BgMGDIClpSVeeOEFbNkifY0Ml0RERERPK34L8HMYkH1Luz07uajdwAFTX9HR0Rg8eDDOnj2LXr164bXXXkNGRoak+2C4JCIiInoaahWwfRKA0q57/F/b9slF/SqJ8PBwDB06FN7e3pg5cyZycnJw7NgxSffBcElERET0NJIO6x6x1CKA7JtF/SqJpk2bav5vZWUFGxsbpKWlSboPhksiIiKip5GTKm2/ZyCXy3VGjhcUFOj0MzU11Xouk8mgVqulrUXSrRERERHVFLWcpe33DBwdHZGcnKx5np2djcTERIPvtzQMl0RERERPw6MdYOMGQFZGBxlg81xRPwPr0qULfvjhBxw4cADnzp3D8OHDoVAYdiqksjBcEhERET0NuQIInvO/JyUD5v+eB882+HyXADBlyhR06tQJffr0Qe/evRESEoL69esbfL+l4STqRERERE/Ltx8w+PuiUeOPDu6xcSsKlr79DLbr/Px81KpVq2h3NjZYv3691vLhw4drPS/tbj6ZmZmS18VwSURERPQsfPsBjXpX2B16CgsLcenSJcTGxuLNN980yD6eBcMlERER0bOSKwCvDhWyq/Pnz6Ndu3bo3Lkz3nrrrQrZpz4YLomIiIiqkObNmyM3N9fYZZSJA3qIiIiISDIMl0REREQkGYZLIiIiIpIMwyURERERSYbhkoiIiIgkw3BJRERERJJhuCQiIiIiyTBcEhEREZFkOIk6ERER0TNSqVU4lXYK6bnpcLR0hL+TPxQGuv1jZccjl0RERETPYHfSbvTY2AMjd4zEpAOTMHLHSPTY2AO7k3YbdL+//vor/Pz8YGFhAQcHBwQFBeH+/fsAgG+++QY+Pj5QKpVo1KgRli5dqlnv2rVrkMlkWL9+Pdq1awelUokmTZrg77//lqQuhksiIiKip7Q7aTciYyKRmpuq1Z6Wm4bImEiDBczk5GQMHToUI0eOREJCAmJiYjBw4EAIIbB27VpMmzYNn332GRISEjBz5kx8/PHHWLNmjdY2PvjgA7z//vs4ffo0AgIC0LdvX9y5c+eZa2O4JCIiInoKKrUKs4/NhoDQWVbcNufYHKjUKsn3nZycjMLCQgwcOBCenp7w8/PD2LFjUatWLURFRWHevHkYOHAgvLy8MHDgQLz33ntYsWKF1jYiIiIQGhoKHx8fLFu2DLa2tvj222+fuTZec0lERET0FE6lndI5YvkoAYGU3BScSjuF1i6tJd13s2bN0LVrV/j5+aFHjx7o3r07Bg0aBDMzM1y9ehWjRo3C6NGjNf0LCwtha2urtY2AgADN/01MTNCqVSskJCQ8c20Ml0RERERPIT03XdJ++lAoFNi1axcOHz6MnTt3YtGiRfjPf/6DrVu3AgC+/vprtG3bVmedisDT4kRERERPwdHSUdJ++pLJZAgMDER0dDROnz4NMzMzHDp0CG5ubvjnn3/g7e2t9fDy8tJa/8iRI5r/FxYW4uTJk/Dx8XnmunjkkoiIiOgp+Dv5w9nSGWm5aaVedymDDM6WzvB38pd830ePHsWePXvQvXt3ODk54ejRo0hPT4ePjw+io6PxzjvvwNbWFsHBwcjPz8eJEydw9+5dREZGaraxZMkSvPDCC/Dx8cGXX36Ju3fvYuTIkc9cm1GPXM6aNQutW7eGtbU1nJycEBISgosXL2r1ycvLw7hx4+Dg4IBatWohNDQUqana1zdcv34dvXv3hqWlJZycnPDBBx+gsLCwIl8KERER1TAKuQKT20wGUBQkH1X8fFKbSQaZ79LGxgb79+9Hr1690KBBA3z00UeYN28eevbsiTfeeAPffPMNVq1aBT8/P3Tq1AmrV6/WOXI5e/ZszJ49G82aNcPBgwexZcsW1KlT55lrkwkhdKN2BQkODsaQIUPQunVrFBYWYurUqTh//jzi4+NhZWUFAHj77bfx559/YvXq1bC1tUVERATkcjkOHToEAFCpVGjevDlcXFzwxRdfIDk5GWFhYRg9ejRmzpxZrjqys7Nha2uLrKws2NjYGOz1EhERUeWSl5eHxMREeHl5QalUPtU2diftxuxjs7UG97hYumBSm0kI8giSqlTJXLt2DV5eXjh9+jSaN29ernX0eZ+MGi5LSk9Ph5OTE/7++2907NgRWVlZcHR0xLp16zBo0CAAwIULF+Dj44PY2Fi8+OKL2LZtG/r06YNbt27B2dkZALB8+XJMmjQJ6enpMDMze+J+GS6JiIhqJinCJVC17tBj6HBZqQb0ZGVlAQDs7e0BACdPnkRBQQGCgv4/9Tdq1AjPP/88YmNjAQCxsbHw8/PTBEsA6NGjB7Kzs/Hf//63AqsnIiKimkohV6C1S2v0qtcLrV1aV9pgWREqzYAetVqNCRMmIDAwEE2aNAEApKSkwMzMDHZ2dlp9nZ2dkZKSounzaLAsXl68rDT5+fnIz8/XPM/OzgYAFBQUoKCgQJLXQ0RERIZnampq7BKqHE9PTxjyxHWlCZfjxo3D+fPncfDgQYPva9asWYiOjtZp37lzJywtLQ2+fyIiIpJG//79jV0ClVApwmVERAT++OMP7N+/H3Xr1tW0u7i44OHDh8jMzNQ6epmamgoXFxdNn2PHjmltr3g0eXGfkqZMmaI1FD87Oxvu7u7o3r07r7kkIiKqgSrREJRKSZ/3x6jhUgiB8ePHY/PmzYiJidEZIt+yZUuYmppiz549CA0NBQBcvHgR169f19yyKCAgAJ999hnS0tLg5OQEANi1axdsbGzg6+tb6n7Nzc1hbm6u025qasrD60RERDVI8V1rHj58CAsLCyNXU3nl5uYCKN9lCEYNl+PGjcO6devw+++/w9raWnONpK2tLSwsLGBra4tRo0YhMjIS9vb2sLGxwfjx4xEQEIAXX3wRANC9e3f4+vpi2LBh+Pzzz5GSkoKPPvoI48aNKzVAEhERERUzMTGBpaUl0tPTYWpqCrm8Uo11NjohBHJzc5GWlgY7O7ty3ULSqFMRyWSyUttXrVqF8PBwAEVD399//3389NNPyM/PR48ePbB06VKtU95JSUl4++23ERMTAysrKwwfPhyzZ8+GiUn5sjOnIiIiIqq5Hj58iMTERKjVamOXUmnZ2dnBxcWlzOz2qEo1z6WxMFwSERHVbGq1Gg8fPjR2GZWSqalpuY5YFqsUA3qIiIiIjEkulz/TJOr0/3hhARERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWRMnmalgoICpKSkIDc3F46OjrC3t5e6LiIiIiKqgsp95PLevXtYtmwZOnXqBBsbG3h6esLHxweOjo7w8PDA6NGjcfz4cUPWSkRERESVXLnC5fz58+Hp6YlVq1YhKCgIv/32G+Li4nDp0iXExsYiKioKhYWF6N69O4KDg3H58mVD101ERERElZBMCCGe1Gno0KH46KOP0Lhx48f2y8/Px6pVq2BmZoaRI0dKVqShZWdnw9bWFllZWbCxsTF2OURERERVVrnCZXXHcElEREQkDY4WJyIiIiLJ6D1aPC8vD4sWLcK+ffuQlpYGtVqttfzUqVOSFUdEREREVYve4XLUqFHYuXMnBg0ahDZt2kAmkxmiLiIiIiKqgvS+5tLW1hZ//fUXAgMDDVVTheM1l0RERETS0Puay+eeew7W1taGqIWIiIiIqji9w+W8efMwadIkJCUlGaIeIiIiIqrC9L7mslWrVsjLy0O9evVgaWkJU1NTreUZGRmSFUdEREREVYve4XLo0KG4efMmZs6cCWdnZw7oISIiIiINvcPl4cOHERsbi2bNmhmiHiIiIiKqwvS+5rJRo0Z48OCBIWohIiIioipO73A5e/ZsvP/++4iJicGdO3eQnZ2t9SAiIiKimkvveS7l8qI8WvJaSyEEZDIZVCqVdNVVEM5zSURERCQNva+53LdvnyHqICIiIqJqQO/T4p06dXrsQx/79+9H37594ebmBplMht9++01reXh4OGQymdYjODhYq09GRgZee+012NjYwM7ODqNGjUJOTo6+L4uIiIiIJKD3kUsAyMvLw9mzZ5GWlga1Wq21rF+/fuXezv3799GsWTOMHDkSAwcOLLVPcHAwVq1apXlubm6utfy1115DcnIydu3ahYKCAowYMQJjxozBunXr9HhFRERERCQFvcPl9u3bERYWhtu3b+ss0/eay549e6Jnz56P7WNubg4XF5dSlyUkJGD79u04fvw4WrVqBQBYtGgRevXqhblz58LNza3ctRARERHRs9M7XI4fPx4vv/wypk2bBmdnZ0PUpCUmJgZOTk6oXbs2unTpgk8//RQODg4AgNjYWNjZ2WmCJQAEBQVBLpfj6NGjGDBgQKnbzM/PR35+vuZ58Sj3goICFBQUGPDVEBERkZRK3imQjE/vcJmamorIyMgKCZbBwcEYOHAgvLy8cPXqVUydOhU9e/ZEbGwsFAoFUlJS4OTkpLWOiYkJ7O3tkZKSUuZ2Z82ahejoaJ32nTt3wtLSUvLXQURERIbRv39/Y5dAJegdLgcNGoSYmBjUr1/fEPVoGTJkiOb/fn5+aNq0KerXr4+YmBh07dr1qbc7ZcoUREZGap5nZ2fD3d0d3bt351RERERERM9A73C5ePFivPzyyzhw4AD8/Px0Dke/8847khVXUr169VCnTh1cuXIFXbt2hYuLC9LS0rT6FBYWIiMjo8zrNIGi6zhLDgwCig6t8/A6ERER0dPTO1z+9NNP2LlzJ5RKJWJiYrQmU5fJZAYNlzdu3MCdO3fg6uoKAAgICEBmZiZOnjyJli1bAgD27t0LtVqNtm3bGqwOIiIiIiqd3nfocXFxwTvvvIPJkydr7tbztHJycnDlyhUAQIsWLTB//nx07twZ9vb2sLe3R3R0NEJDQ+Hi4oKrV6/iww8/xL1793Du3DnNkceePXsiNTUVy5cv10xF1KpVK72mIuIdeoiIiIikoXe4tLe3x/HjxyW55jImJgadO3fWaR8+fDiWLVuGkJAQnD59GpmZmXBzc0P37t0xY8YMrcFEGRkZiIiIwNatWyGXyxEaGoqFCxeiVq1a5a6D4ZKIiIhIGnqHy/feew+Ojo6YOnWqoWqqcAyXRERERNLQ+5pLlUqFzz//HDt27EDTpk11BsDMnz9fsuKIiIiIqGrRO1yeO3cOLVq0AACcP39ea9mjg3uIiIiIqObR+7R4dcTT4kRERETSeLbh3kREREREjyhXuHzrrbdw48aNcm1ww4YNWLt27TMVRURERERVU7muuXR0dETjxo0RGBiIvn37olWrVnBzc4NSqcTdu3cRHx+PgwcPYv369XBzc8PKlSsNXTcRERERVULlvuYyNTUV33zzDdavX4/4+HitZdbW1ggKCsIbb7yB4OBggxRqSLzmkoiIiEgaTzWg5+7du7h+/ToePHiAOnXqoH79+lV6pDjDJREREZE09J6KCABq166N2rVrS10LEREREVVxHC1ORERERJJhuCQiIiIiyTBcEhEREZFkGC6JiIiISDIMl0REREQkGb3DZWpqKoYNGwY3NzeYmJhAoVBoPYiIiIio5tJ7KqLw8HBcv34dH3/8MVxdXav0/JZEREREJC29w+XBgwdx4MABNG/e3ADlEBEREVFVpvdpcXd3dzzFTX2IiIiIqAbQO1wuWLAAkydPxrVr1wxQDhERERFVZXrfW7x27drIzc1FYWEhLC0tYWpqqrU8IyND0gIrAu8tTkRERCQNva+5XLBggQHKICIiIqLqQO8jl9URj1wSERERSUPvI5cAoFKp8NtvvyEhIQEA0LhxY/Tr14/zXBIRERHVcHofubxy5Qp69eqFmzdvomHDhgCAixcvwt3dHX/++Sfq169vkEINiUcuiYiIiKShd7js1asXhBBYu3Yt7O3tAQB37tzB66+/Drlcjj///NMghRoSwyURERGRNPQOl1ZWVjhy5Aj8/Py02s+cOYPAwEDk5ORIWmBFYLgkIiIikobe81yam5vj3r17Ou05OTkwMzOTpCgiIiIiqpr0Dpd9+vTBmDFjcPToUQghIITAkSNH8NZbb6Ffv36GqJGIiIiIqgi9w+XChQtRv359BAQEQKlUQqlUIjAwEN7e3vjqq68MUSMRERERVRFPPc/l5cuXceHCBQCAj48PvL29JS2sIvGaSyIiIiJpcBJ1MFwSERERSaVck6hHRkZixowZsLKyQmRk5GP7zp8/X5LCiIiIiKjqKVe4PH36NAoKCjT/JyIiIiIqDU+Lg6fFiYiIiKSi92jxkSNHljrP5f379zFy5EhJiiIiIiKiqknvI5cKhQLJyclwcnLSar99+zZcXFxQWFgoaYEVgUcuiYiIiKRRrmsugaIAVjxp+r1796BUKjXLVCoV/vrrL53ASUREREQ1S7nDpZ2dHWQyGWQyGRo0aKCzXCaTITo6WtLiiIiIiKhqKXe43LdvH4QQ6NKlCzZu3Ah7e3vNMjMzM3h4eMDNzc0gRRIRERFR1aD3NZdJSUlwd3eHXK73WKBKi9dcEhEREUmj3Ecui3l4eAAAcnNzcf36dTx8+FBredOmTaWpjIiIiIiqHL3DZXp6OkaMGIFt27aVulylUj1zUURERERUNel9bnvChAnIzMzE0aNHYWFhge3bt2PNmjV44YUXsGXLFkPUSERERERVhN5HLvfu3Yvff/8drVq1glwuh4eHB7p16wYbGxvMmjULvXv3NkSdRERERFQF6H3k8v79+5r5LGvXro309HQAgJ+fH06dOiVtdURERERUpegdLhs2bIiLFy8CAJo1a4YVK1bg5s2bWL58OVxdXSUvkIiIiIiqDr1Pi7/77rtITk4GAERFRSE4OBhr166FmZkZVq9eLXV9RERERFSF6D3PZUm5ubm4cOECnn/+edSpU0equioU57kkIiIikobep8U/+eQT5Obmap5bWlrC398fVlZW+OSTTyQtjoiIiIiqFr2PXCoUCiQnJ2sG9RS7c+cOnJycquQ8lzxySURERCQNvY9cCiEgk8l02s+cOaN1v3EiIiIiqnnKPaCndu3akMlkkMlkaNCggVbAVKlUyMnJwVtvvWWQIomIiIioaih3uFywYAGEEBg5ciSio6Nha2urWWZmZgZPT08EBAQYpEgiIiIiqhr0vuby77//Rrt27WBqamqomiocr7kkIiIikka5jlxmZ2drQleLFi3w4MEDPHjwoNS+DGdERERENVe5wmXt2rU1I8Tt7OxKHdBTPNCnKo4WJyIiIiJplCtc7t27VzMSfN++fQYtiIiIiIiqrme+Q091wGsuiYiIiKSh973FAeDu3bv49ttvkZCQAADw9fXFiBEjOM8lERERUQ2n9yTq+/fvh6enJxYuXIi7d+/i7t27WLhwIby8vLB//35D1EhEREREVYTep8X9/PwQEBCAZcuWQaFQACiaRH3s2LE4fPgwzp07Z5BCDYmnxYmIiIikoXe4tLCwQFxcHBo2bKjVfvHiRTRv3rzMKYoqM4ZLIiIiImnofVrc399fc63loxISEtCsWTNJiiIiIiKiqknvcPnOO+/g3Xffxdy5c3Hw4EEcPHgQc+fOxXvvvYf33nsPZ8+e1TyeZP/+/ejbty/c3Nwgk8nw22+/aS0XQmDatGlwdXWFhYUFgoKCcPnyZa0+GRkZeO2112BjYwM7OzuMGjUKOTk5+r4sIiIiIpKA3qfF5fLH51GZTFbuCdW3bduGQ4cOoWXLlhg4cCA2b96MkJAQzfI5c+Zg1qxZWLNmDby8vPDxxx/j3LlziI+Ph1KpBAD07NkTycnJWLFiBQoKCjBixAi0bt0a69atK/dr4mlxIiIiImnoHS6TkpLK3dfDw6P8hchkWuFSCAE3Nze8//77mDhxIgAgKysLzs7OWL16NYYMGYKEhAT4+vri+PHjaNWqFQBg+/bt6NWrF27cuAE3N7dy7ZvhkoiIiEgaes9zqU9gfBaJiYlISUlBUFCQps3W1hZt27ZFbGwshgwZgtjYWNjZ2WmCJQAEBQVBLpfj6NGjGDBgQKnbzs/PR35+vuZ5dnY2AKCgoAAFBQUGekVEREQkNVNTU2OXQCWUK1xu2bIFPXv2hKmpKbZs2fLYvv369ZOksJSUFACAs7OzVruzs7NmWUpKCpycnLSWm5iYwN7eXtOnNLNmzUJ0dLRO+86dO2FpafmspRMREVEF6d+/v7FLoBLKFS5DQkI0Qe7RayJLKs91lpXBlClTEBkZqXmenZ0Nd3d3dO/enafFiYiIiJ5BucKlWq0u9f+G5OLiAgBITU2Fq6urpj01NRXNmzfX9ElLS9Nar7CwEBkZGZr1S2Nubg5zc3OddlNTUx5eJyIiInoGek9FVFG8vLzg4uKCPXv2aNqys7Nx9OhRBAQEAAACAgKQmZmJkydPavrs3bsXarUabdu2rfCaiYiIiGq6p5rncuHChTrtixcvxoQJE/TaVk5ODuLi4hAXFwegaBBPXFwcrl+/DplMhgkTJuDTTz/Fli1bcO7cOYSFhcHNzU1zat7HxwfBwcEYPXo0jh07hkOHDiEiIgJDhgwp90hxIiIiIpKO3lMRPffcc9iyZQtatmyp1X7q1Cn069cPN27cKPe2YmJi0LlzZ5324cOHY/Xq1RBCICoqCitXrkRmZibat2+PpUuXokGDBpq+GRkZiIiIwNatWyGXyxEaGoqFCxeiVq1a5a6DUxERERERSUPvcKlUKnH+/Hl4e3trtV+5cgVNmjRBXl6epAVWBIZLIiIiImnofVrc29sb27dv12nftm0b6tWrJ0lRRERERFQ16T2JemRkJCIiIpCeno4uXboAAPbs2YN58+ZhwYIFUtdHRERERFWI3qfFAWDZsmX47LPPcOvWLQCAp6cnpk+fjrCwMMkLrAg8LU5EREQkjacKl8XS09NhYWGh1+CZyojhkoiIiEgaTzXPZWFhIXbv3o1NmzahOJveunULOTk5khZHRERERFWL3tdcJiUlITg4GNevX0d+fj66desGa2trzJkzB/n5+Vi+fLkh6iQiIiKiKkDvI5fvvvsuWrVqhbt378LCwkLTPmDAAK276RARERFRzaP3kcsDBw7g8OHDMDMz02r39PTEzZs3JSuMiIiIiKoevY9cqtVqqFQqnfYbN27A2tpakqKIiIiIqGrSO1x2795daz5LmUyGnJwcREVFoVevXlLWRkRERFWZWgUkHgDO/Vr0r1r34BRVP3pPRfTvv/8iODgYQghcvnwZrVq1wuXLl1GnTh3s378fTk5OhqrVYDgVERERkcTitwDbJwHZt/6/zcYNCJ4D+PYzXl1kcE81z2VhYSE2bNiAM2fOICcnB/7+/njttde0BvhUJQyXREREEorfAvwcBqBkxJAV/TP4ewbMakyvcFlQUIBGjRrhjz/+gI+PjyHrqlAMl0RERBJRq4AFTbSPWGqRFR3BnHAOkCsqtDSqGHpdc2lqaoq8vDxD1UJERERVXdLhxwRLABBA9s2iflQt6T2gZ9y4cZgzZw4KCwsNUQ8RERFVZTmp0vajKkfveS6PHz+OPXv2YOfOnfDz84OVlZXW8k2bNklWHBEREVUxtZyl7UdVjt7h0s7ODqGhoYaohYiIiKo6j3ZF11RmJ0N3QA+guebSo11FV0YV5KlGi1c3HNBDREQkIc1ocUA7YHK0eE1Q7msu1Wo15syZg8DAQLRu3RqTJ0/GgwcPDFkbERERVUW+/YoCpI2rdruNG4NlDVDu0+KfffYZpk+fjqCgIFhYWOCrr75CWloavvvuO0PWR0RERFWRbz+gUe+iUeE5qUXXWHq04/RDNUC5T4u/8MILmDhxIt58800AwO7du9G7d288ePAAcrneg84rFZ4WJyIiIpJGuVPh9evXte4dHhQUBJlMhlu3HjeXFRERERHVJOUOl4WFhVAqlVptpqamKCgokLwoIiIiIqqayn3NpRAC4eHhMDc317Tl5eXhrbfe0prrkvNcEhEREdVc5Q6Xw4cP12l7/fXXJS2GiIiIiKo2znMJDughIiIikkrVHuZNRERERJUKwyURERERSYbhkoiIiIgkU+4BPUREVY5axbuDEBFVMIZLIqqe4rcA2ycB2Y/c6MHGDQiew/saExEZEE+LE1H1E78F+DlMO1gCQHZyUXv8FuPURURUAzBcElH1olYVHbFEabOs/a9t++SifkREJDmGSyKqXpIO6x6x1CKA7JtF/YiISHIMl0RUveSkStuPiIj0wnBJRNVLLWdp+xERkV4YLomoevFoVzQqHLIyOsgAm+eK+hERkeQYLomoepEriqYbAqAbMP/3PHg257skIjIQhksiqn58+wGDvwdsXLXbbdyK2jnPJRGRwciEEKXN11GjZGdnw9bWFllZWbCxsTF2OUQkFd6hh4iowvEOPURUfckVgFcHY1dBRFSj8LQ4EREREUmG4ZKIiIiIJMNwSURERESSYbgkIiIiIskwXBIRERGRZBguiYiIiEgyDJdEREREJBmGSyIiIiKSDMMlEREREUmG4ZKIiIiIJMNwSURERESSYbgkIiIiIskwXBIRERGRZBguiYiIiEgyDJdEREREJBmGSyIiIiKSjImxCyAiMhSVWoVTaaeQnpsOR0tH+Dv5QyFXGLssIqJqjeGSiKql3Um7MfvYbKTmpmranC2dMbnNZAR5BBmxMiKi6o2nxYmo2tmdtBuRMZFawRIA0nLTEBkTid1Ju41UGRFR9cdwSUTVikqtwuxjsyEgdJYVt805NgcqtaqiSyMiqhEYLomoWjmVdkrniOWjBARSclNwKu1UBVZFRFRzMFwSUbWSnpsuaT8iItIPwyURVSuOlo6S9iMiIv1U6nA5ffp0yGQyrUejRo00y/Py8jBu3Dg4ODigVq1aCA0NRWpq2afDiKj683fyh7OlM2SQlbpcBhlcLF3g7+RfwZUREdUMlTpcAkDjxo2RnJyseRw8eFCz7L333sPWrVvxyy+/4O+//8atW7cwcOBAI1ZLRMamkCswuc1kANAJmMXPJ7WZxPkuiYgMpNLPc2liYgIXFxed9qysLHz77bdYt24dunTpAgBYtWoVfHx8cOTIEbz44osVXSoRVRJBHkGY/9L8Uue5nNRmEue5JCIyoEofLi9fvgw3NzcolUoEBARg1qxZeP7553Hy5EkUFBQgKOj/f0k0atQIzz//PGJjYx8bLvPz85Gfn695np2dDQAoKChAQUGB4V4MEVWYTm6d0L5fe5xOP43bD26jjkUdtHBsAYVcwe9zomrE1NTU2CVQCZU6XLZt2xarV69Gw4YNkZycjOjoaHTo0AHnz59HSkoKzMzMYGdnp7WOs7MzUlJSHrvdWbNmITo6Wqd9586dsLS0lPIlEFElkYY07MAOY5dBRBLr37+/sUugEmRCCN2ZhiupzMxMeHh4YP78+bCwsMCIESO0jkACQJs2bdC5c2fMmTOnzO2UduTS3d0dt2/fho2NjcHqJyIiqklUalWpZw+kxCOXlU+lPnJZkp2dHRo0aIArV66gW7duePjwITIzM7WOXqamppZ6jeajzM3NYW5urtNuamrKL1IiIiIJ7E7aXep1z5PbTOZ1z9VcpR8t/qicnBxcvXoVrq6uaNmyJUxNTbFnzx7N8osXL+L69esICAgwYpVEREQ12+6k3YiMidS5W1ZabhoiYyKxO2m3kSqjilCpT4tPnDgRffv2hYeHB27duoWoqCjExcUhPj4ejo6OePvtt/HXX39h9erVsLGxwfjx4wEAhw8f1ms/2dnZsLW1RVZWFk+LExERPQOVWoUeG3uUeRtWGWRwtnTG9tDtnBKsmqrUp8Vv3LiBoUOH4s6dO3B0dET79u1x5MgRODoW3Vnjyy+/hFwuR2hoKPLz89GjRw8sXbrUyFUTERHVXKfSTpUZLAFAQCAlNwWn0k6htUvrCqyMKkqlDpfr169/7HKlUoklS5ZgyZIlFVQRERERPU56brqk/ajqqVLXXBIREVHl5mjpKGk/qnoYLomIiEgy/k7+cLZ01rn9ajEZZHCxdIG/k38FV0YVheGSiIiIJKOQKzC5zWQA0AmYxc8ntZnEwTzVGMMlERERSSrIIwjzX5oPJ0snrXZnS2fMf2k+57ms5ir1VEQVhVMRERERSU+lVuFU2imk56bD0dIR/k7+PGJZA1Tq0eJERERUdSnkCk43VAPxtDgRERERSYZHLg2EpwKIiIioJmK4NIDdSbsx+9hsrTsUOFs6Y3KbybyImYiIiKo1nhaX2O6k3YiMidS59VVabhoiYyKxO2m3kSojIiIiMjyGSwmp1CrMPjYbAroD8Ivb5hybA5VaVdGlEREREVUIhksJnUo7pXPE8lECAim5KTiVdqoCqyIiIiKqOAyXEkrPTZe0HxEREVFVw3ApIUdLR0n7EREREVU1DJcS8nfyh7Ols869VIvJIIOLpQv8nfwruDIiIiKiisFwKSGFXIHJbSYDgE7ALH4+qc0kzndJRERE1RbDpcSCPIIw/6X5cLJ00mp3tnTG/Jfmc55LIiIiqtZkQgjdeXNqmOzsbNja2iIrKws2NjaSbJN36CEiIqKaiHfoMRCFXIHWLq2NXQYRERFRheJpcSIiIiKSDMMlEREREUmGp8UNRKUWOJaYgbR7eXCyVqKNlz0U8tKnKCIiIiKqLhguDWD7+WREb41Hclaeps3VVomovr4IbuJqxMqIiIiIDIunxSW2/Xwy3v7xlFawBICUrDy8/eMpbD+fbKTKiIiIiAyP4VJCKrVA9NZ4lDa3U3Fb9NZ4qNQ1fvYnIiIiqqYYLiV0LDFD54jlowSA5Kw8HEvMqLiiiIiIiCoQw6WE0u6VHSyfph8RERFRVcNwKSEna6Wk/YiIiIiqGoZLCbXxsoerrRJlTTgkQ9Go8TZe9hVZFhEREVGFYbiUkEIuQ1RfXwDQCZjFz6P6+nK+SyIiIqq2GC4lFtzEFcte94eLrfapbxdbJZa97s95LomIiKhakwkhavy8ONnZ2bC1tUVWVhZsbGwk2Sbv0ENEREQ1Ee/QYyAKuQwB9R2MXQYRERFRheJpcSIiIiKSDMMlEREREUmG4ZKIiIiIJMNwSURERESSYbgkIiIiIskwXBIRERGRZBguiYiIiEgynOfSUNQqIOkwkJMK1HIGPNoBcoWxqyIiIiIyKIZLQ4jfAmyfBGTf+v82GzcgeA7g2894dREREREZGE+LSy1+C/BzmHawBIDs5KL2+C3GqYuIiIioAjBcSkmtKjpiidJu1/6/tu2Ti/oRERERVUMMl1JKOqx7xFKLALJvFvUjIiIiqoYYLqWUkyptPyIiIqIqhuFSSrWcpe1HREREVMUwXErJo13RqHDIyuggA2yeK+pHREREVA0xXEpJriiabgiAbsD83/Pg2ZzvkoiIagSVWiD26h38HncTsVfvQKUubcArVTcyIUSN/6Szs7Nha2uLrKws2NjYPPsGS53n8rmiYMl5LomIqAbYfj4Z0VvjkZyVp2lztVUiqq8vgpu4GrEyMjSGSxggXAK8Qw8REdVY288n4+0fT+lMzFd8Tm/Z6/4MmNUY79BjKHIF4NXB2FUQERFVKJVaIHprfJkzPssARG+NRzdfFyjkZY1RoKqM11wSERGRZI4lZmidCi9JAEjOysOxxIyKK4oqFMMlERERSSbtXtnB8mn6UdXDcElERESScbJWStqPqh6GSyIiIpJMGy97uNoqHzfjM1xtlWjjZV+RZVEFYrgkIiIiySjkMkT19QVQ5ozPiOrry8E81RjDJREREUkquIkrlr3uDxdb7VPfLrZKTkNUA3CeSxhonksiIqIaTqUWOJaYgbR7eXCyLjoVziOW1R/nuSQiIiKDUMhlCKjvYOwyqILxtDgRERERSYbhkoiIiIgkw3BJRERERJKpNuFyyZIl8PT0hFKpRNu2bXHs2DFjl0RERERU41SLcLlhwwZERkYiKioKp06dQrNmzdCjRw+kpaUZuzQiIiKiGqVaTEXUtm1btG7dGosXLwYAqNVquLu7Y/z48Zg8efIT1+dURERERETSqPJTET18+BAnT57ElClTNG1yuRxBQUGIjY0tdZ38/Hzk5+drnmdnZwMACgoKUFBQYNiCiYiISDKmpqbGLoFKqPLh8vbt21CpVHB2dtZqd3Z2xoULF0pdZ9asWYiOjtZp37lzJywtLQ1SJxEREUmvf//+xi6BSqjy4fJpTJkyBZGRkZrn2dnZcHd3R/fu3XlanIiIiOgZVPlwWadOHSgUCqSmpmq1p6amwsXFpdR1zM3NYW5urnlefNnpgwcPeHidiIioCnnw4AGsra0hk/G2kpVFlQ+XZmZmaNmyJfbs2YOQkBAARQN69uzZg4iIiHJt4969ewAAd3d3Q5VJREREBsIBuZVLlQ+XABAZGYnhw4ejVatWaNOmDRYsWID79+9jxIgR5Vrfzc0N//77r+R/+RSfbv/333/5RU9kJPw+JDKuivgetLa2Nsh26elUi3D5yiuvID09HdOmTUNKSgqaN2+O7du36wzyKYtcLkfdunUNVp+NjQ1/qREZGb8PiYyL34M1R7WY57Ky4vyZRMbH70Mi4+L3YM1TLe7QQ0RERESVA8OlAZmbmyMqKkprZDoRVSx+HxIZF78Hax6eFiciIiIiyfDIJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiogq3evVq2NnZGXw/165dg0wmQ1xcnMH3RUUYLh8RHh4OmUwGmUwGU1NTODs7o1u3bvjuu++gVquNWhu/OagmefR78dHHlStXjFZP8e1liaqilJQUvPvuu/D29oZSqYSzszMCAwOxbNky5ObmGrs8qmaqxR16pBQcHIxVq1ZBpVIhNTUV27dvx7vvvotff/0VW7ZsgYlJxb9lDx8+rPB9Ehlb8ffioxwdHfXezsOHD2FmZiZVWURVzj///IPAwEDY2dlh5syZ8PPzg7m5Oc6dO4eVK1fiueeeQ79+/XTWKygogKmpqREqpqqORy5LMDc3h4uLC5577jn4+/tj6tSp+P3337Ft2zasXr0aAJCZmYk33ngDjo6OsLGxQZcuXXDmzBnNNs6cOYPOnTvD2toaNjY2aNmyJU6cOKFZfvDgQXTo0AEWFhZwd3fHO++8g/v372uWe3p6YsaMGQgLC4ONjQ3GjBkDLy8vAECLFi0gk8nw0ksvVcj7QWQsxd+Ljz4UCgX+/vtvtGnTBubm5nB1dcXkyZNRWFioWe+ll15CREQEJkyYgDp16qBHjx4AgPPnz6Nnz56oVasWnJ2dMWzYMNy+fVuz3q+//go/Pz9YWFjAwcEBQUFBuH//PqZPn441a9bg999/1xxBjYmJqei3g+ipjR07FiYmJjhx4gQGDx4MHx8f1KtXD/3798eff/6Jvn37AgBkMhmWLVuGfv36wcrKCp999hlUKhVGjRoFLy8vWFhYoGHDhvjqq6+0th8TE4M2bdrAysoKdnZ2CAwMRFJSEoAn/z581NWrV9G/f384OzujVq1aaN26NXbv3q3Vx9PTEzNnzsTIkSNhbW2N559/HitXrtTqc+zYMbRo0QJKpRKtWrXC6dOnpXorqZwYLsuhS5cuaNasGTZt2gQAePnll5GWloZt27bh5MmT8Pf3R9euXZGRkQEAeO2111C3bl0cP34cJ0+exOTJkzV//V29ehXBwcEIDQ3F2bNnsWHDBhw8eBARERFa+5w7dy6aNWuG06dP4+OPP8axY8cAALt370ZycrKmFqKa5ObNm+jVqxdat26NM2fOYNmyZfj222/x6aefavVbs2YNzMzMcOjQISxfvhyZmZno0qULWrRogRMnTmD79u1ITU3F4MGDAQDJyckYOnQoRo4ciYSEBMTExGDgwIEQQmDixIkYPHgwgoODkZycjOTkZLRr184YL59Ib3fu3MHOnTsxbtw4WFlZldpHJpNp/j99+nQMGDAA586dw8iRI6FWq1G3bl388ssviI+Px7Rp0zB16lT8/PPPAIDCwkKEhISgU6dOOHv2LGJjYzFmzBjNNh/3+7CknJwc9OrVC3v27MHp06cRHByMvn374vr161r95s2bpwmNY8eOxdtvv42LFy9qttGnTx/4+vri5MmTmD59OiZOnPjM7yPpSZDG8OHDRf/+/Utd9sorrwgfHx9x4MABYWNjI/Ly8rSW169fX6xYsUIIIYS1tbVYvXp1qdsZNWqUGDNmjFbbgQMHhFwuFw8ePBBCCOHh4SFCQkK0+iQmJgoA4vTp00/xyoiqluHDhwuFQiGsrKw0j0GDBompU6eKhg0bCrVarem7ZMkSUatWLaFSqYQQQnTq1Em0aNFCa3szZswQ3bt312r7999/BQBx8eJFcfLkSQFAXLt2rcx6yvrZQFSZHTlyRAAQmzZt0mp3cHDQfG99+OGHQgghAIgJEyY8cZvjxo0ToaGhQggh7ty5IwCImJiYUvs+7vfhqlWrhK2t7WP31bhxY7Fo0SLNcw8PD/H6669rnqvVauHk5CSWLVsmhBBixYoVwsHBQfP7VAghli1bxt+fFYxHLstJCAGZTIYzZ84gJycHDg4OqFWrluaRmJiIq1evAgAiIyPxxhtvICgoCLNnz9a0A0WnCFavXq21bo8ePaBWq5GYmKjp16pVqwp/jUSVSefOnREXF6d5LFy4EAkJCQgICNA60hIYGIicnBzcuHFD09ayZUutbZ05cwb79u3T+r5r1KgRgKKzCc2aNUPXrl3h5+eHl19+GV9//TXu3r1bMS+UyAiOHTuGuLg4NG7cGPn5+Zr20n73LFmyBC1btoSjoyNq1aqFlStXao4m2tvbIzw8HD169EDfvn3x1VdfITk5WbPu434flpSTk4OJEyfCx8cHdnZ2qFWrFhISEnSOXDZt2lTzf5lMBhcXF6SlpQEAEhIS0LRpUyiVSk2fgIAAPd8delYMl+WUkJAALy8v5OTkwNXVVeuXXlxcHC5evIgPPvgAQNFphf/+97/o3bs39u7dC19fX2zevBlA0TfPm2++qbXumTNncPnyZdSvX1+zv7JOXxDVFFZWVvD29tY8XF1d9Vr3UTk5Oejbt6/O9+3ly5fRsWNHKBQK7Nq1C9u2bYOvry8WLVqEhg0bav3BR1QVeXt7QyaTaU4bF6tXrx68vb1hYWGh1V7ye2f9+vWYOHEiRo0ahZ07dyIuLg4jRozQGmi6atUqxMbGol27dtiwYQMaNGiAI0eOAHj878OSJk6ciM2bN2PmzJk4cOAA4uLi4OfnpzOoteRpdZlMZvQZXUgbR4uXw969e3Hu3Dm89957qFu3LlJSUmBiYgJPT88y12nQoAEaNGiA9957D0OHDsWqVaswYMAA+Pv7Iz4+Ht7e3nrVUDzaVaVSPctLIarSfHx8sHHjRs2ZBAA4dOgQrK2tUbdu3TLX8/f3x8aNG+Hp6VnmjA8ymQyBgYEIDAzEtGnT4OHhgc2bNyMyMhJmZmb83qMqycHBAd26dcPixYsxfvx4vQ9cHDp0CO3atcPYsWM1baUdfWzRogVatGiBKVOmICAgAOvWrcOLL74IoOzfh6XtKzw8XLMsJycH165d06teHx8f/PDDD8jLy9McvSwOulRxeOSyhPz8fKSkpODmzZs4deoUZs6cif79+6NPnz4ICwtDUFAQAgICEBISgp07d+LatWs4fPgw/vOf/+DEiRN48OABIiIiEBMTg6SkJBw6dAjHjx+Hj48PAGDSpEk4fPgwIiIiNEdOfv/9d50BPSU5OTnBwsJCMxAhKyurIt4Ookpl7Nix+PfffzF+/HhcuHABv//+O6KiohAZGQm5vOwfZ+PGjUNGRgaGDh2K48eP4+rVq9ixYwdGjBgBlUqFo0ePYubMmThx4gSuX7+OTZs2IT09XfN96+npibNnz+LixYu4ffs2CgoKKuolEz2zpUuXorCwEK1atcKGDRuQkJCAixcv4scff8SFCxegUCjKXPeFF17AiRMnsGPHDly6dAkff/wxjh8/rlmemJiIKVOmIDY2FklJSdi5cycuX74MHx+fJ/4+LG1fmzZt0pzRe/XVV/U+Ivnqq69CJpNh9OjRiI+Px19//YW5c+fqtQ2SgLEv+qxMhg8fLgAIAMLExEQ4OjqKoKAg8d1332kGCwghRHZ2thg/frxwc3MTpqamwt3dXbz22mvi+vXrIj8/XwwZMkS4u7sLMzMz4ebmJiIiIrQuLj527Jjo1q2bqFWrlrCyshJNmzYVn332mWa5h4eH+PLLL3Xq+/rrr4W7u7uQy+WiU6dOhnwriIzqcQNoYmJiROvWrYWZmZlwcXERkyZNEgUFBZrlnTp1Eu+++67OepcuXRIDBgwQdnZ2wsLCQjRq1EhMmDBBqNVqER8fL3r06CEcHR2Fubm5aNCggdYggrS0NM33LACxb98+iV8xkWHdunVLRERECC8vL2Fqaipq1aol2rRpI7744gtx//59IUTRgJ7NmzdrrZeXlyfCw8OFra2tsLOzE2+//baYPHmyaNasmRBCiJSUFBESEiJcXV2FmZmZ8PDwENOmTRMqleqJvw9LDuhJTEwUnTt3FhYWFsLd3V0sXrxY5/u5tN+PzZo1E1FRUZrnsbGxolmzZsLMzEw0b95cbNy4kQN6KphMCCGMmm6JiIiIqNrgaXEiIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERlkMlk+O2334xdBhFRlcJwSUQGFR4eDplMpvMIDg42dmlPlJycjJ49exq7DCKiKsXE2AUQUfUXHByMVatWabWZm5sbZF8PHz6EmZmZJNtycXGRZDtERDUJj1wSkcGZm5vDxcVF61G7dm0AQGZmJt588004OztDqVSiSZMm+OOPPzTrbty4EY0bN4a5uTk8PT0xb948rW17enpixowZCAsLg42NDcaMGQMAOHjwIDp06AALCwu4u7vjnXfewf379zXrJScno3fv3rCwsICXlxfWrVsHT09PLFiwQNOn5Gnxc+fOoUuXLrCwsICDgwPGjBmDnJwczfLw8HCEhIRg7ty5cHV1hYODA8aNG4eCggIp304iokqN4ZKIjEatVqNnz544dOgQfvzxR8THx2P27NlQKBQAgJMnT2Lw4MEYMmQIzp07h+nTp+Pjjz/G6tWrtbYzd+5cNGvWDKdPn8bHH3+Mq1evIjg4GKGhoTh79iw2bNiAgwcPIiIiQrNOWFgYbt26hZiYGGzcuBErV65EWlpambXev38fPXr0QO3atXH8+HH88ssv2L17t9Y2AWDfvn24evUq9u3bhzVr1mD16tU69RIRVWuCiMiAhg8fLhQKhbCystJ6fPbZZ2LHjh1CLpeLixcvlrruq6++Krp166bV9sEHHwhfX1/Ncw8PDxESEqLVZ9SoUWLMmDFabQcOHBByuVw8ePBAJCQkCADi+PHjmuWXL18WAMSXX36paQMgNm/eLIQQYuXKlaJ27doiJydHs/zPP/8UcrlcpKSkaF6rh4eHKCws1PR5+eWXxSuvvFKOd4qIqHrgNZdEZHCdO3fGsmXLtNrs7e3xzTffoG7dumjQoEGp6yUkJKB///5abYGBgViwYAFUKpXmCGerVq20+pw5cwZnz57F2rVrNW1CCKjVaiQmJuLSpUswMTGBv7+/Zrm3t7fmVH1ZtTRr1gxWVlZatajValy8eBHOzs4AgMaNG2vqAgBXV1ecO3euzO0SEVU3DJdEZHBWVlbw9vbWabewsJBs+4/KycnBm2++iXfeeUen7/PPP49Lly5Jst/SmJqaaj2XyWRQq9UG2x8RUWXDcElERtO0aVPcuHEDly5dKvXopY+PDw4dOqTVdujQITRo0EDr6GBJ/v7+iI+PLzXQAkDDhg1RWFiI06dPo2XLlgCAK1eu4O7du2Vu08fHB6tXr8b9+/c1YfbQoUOQy+Vo2LDhE18rEVFNwQE9RGRw+fn5SElJ0Xrcvn0bnTp1QseOHREaGopdu3YhMTER27Ztw/bt2wEA77//Pvbs2YMZM2bg0qVLWLNmDRYvXoyJEyc+dn+TJk3C4cOHERERgbi4OFy+fBm///67ZvBNo0aNEBQUhDFjxuDYsWM4ffo0xowZAwsLC8hkslK3+dprr0GpVGL48OE4f/489u3bh/Hjx2PYsGGaU+JERMRwSUQVYPv27XB1ddV6tG/fHkDRVEOtW7fG0KFD4evriw8//BAqlQpA0RHIn3/+GevXr0eTJk0wbdo0fPLJJwgPD3/s/po2bYq///4bly5dQocOHdCiRQtMmzYNbm5umj7ff/89nJ2d0bFjRwwYMACjR4+GtbU1lEplqdu0tLTEjh07kJGRgdatW2PQoEHo2rUrFi9eLM2bRERUTciEEMLYRRARGduNGzfg7u6O3bt3o2vXrsYuh4ioymK4JKIaae/evcjJyYGfnx+Sk5Px4Ycf4ubNm7h06ZLOoBwiIio/DughohqpoKAAU6dOxT///ANra2u0a9cOa9euZbAkInpGPHJJRERERJLhgB4iIiIikgzDJRERERFJhuGSiIiIiCTDcElEREREkmG4JCIiIiLJMFwSERERkWQYLomIiIhIMgyXRERERCQZhksiIiIiksz/AbhwijFzrDYWAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ecoregions.geetools.plot_by_features(\n", - " type = \"scatter\",\n", - " featureId = \"label\",\n", - " properties = ['01_ppt', '06_ppt', '09_ppt'],\n", - " labels = [\"jan\", \"jun\", \"sep\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", - "ax.set_xlabel(\"Ecoregion\")\n", - "ax.set_ylabel(\"Precipitation (mm)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Pie chart\n", - "\n", - "The pie is a property, each slice is the share from each feature whose value is cast as a percentage of the sum of all values of features composing the pie." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ecoregions.geetools.plot_by_features(\n", - " type = \"pie\",\n", - " featureId = \"label\",\n", - " properties = ['06_ppt'],\n", - " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Share of precipitation in June by Ecoregion\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Donut chart\n", - "\n", - "The donut is a property, each slice is the share from each feature whose value is cast as a percentage of the sum of all values of features composing the donut." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ecoregions.geetools.plot_by_features(\n", - " type = \"donut\",\n", - " featureId = \"label\",\n", - " properties = ['07_ppt'],\n", - " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Share of precipitation in July by Ecoregion\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ee.FeatureCollection.geetools.plot_by_properties\n", - "\n", - "## Column chart\n", - "\n", - "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by columns, labeled by values of a selected property." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ax = ecoregions.geetools.plot_by_properties(\n", - " type = \"bar\",\n", - " properties = ['01_ppt', '02_ppt', '03_ppt', '04_ppt', '05_ppt', '06_ppt', '07_ppt', '08_ppt', '09_ppt', '10_ppt', '11_ppt', '12_ppt'],\n", - " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " featureId = \"label\",\n", - " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", - "ax.set_xlabel(\"Month\")\n", - "ax.set_ylabel(\"Precipitation (mm)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Line chart\n", - "\n", - "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by columns, labeled by values of a selected property." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize theplot with the ecoregions data\n", - "ax = ecoregions.geetools.plot_by_properties(\n", - " type = \"plot\",\n", - " properties = [\"01_ppt\", \"02_ppt\", \"03_ppt\", \"04_ppt\", \"05_ppt\", \"06_ppt\", \"07_ppt\", \"08_ppt\", \"09_ppt\", \"10_ppt\", \"11_ppt\", \"12_ppt\"],\n", - " featureId = \"label\",\n", - " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", - "ax.set_xlabel(\"Month\")\n", - "ax.set_ylabel(\"Precipitation (mm)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Area chart \n", - "\n", - "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by lines and shaded areas, labeled by values of a selected property." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# initialize the plot with the ecoregions data\n", - "ax = ecoregions.geetools.plot_by_properties(\n", - " type = \"fill_between\",\n", - " properties = [\"01_ppt\", \"02_ppt\", \"03_ppt\", \"04_ppt\", \"05_ppt\", \"06_ppt\", \"07_ppt\", \"08_ppt\", \"09_ppt\", \"10_ppt\", \"11_ppt\", \"12_ppt\"],\n", - " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " featureId = \"label\",\n", - " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", - " ax = ax\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", - "ax.set_xlabel(\"Month\")\n", - "ax.set_ylabel(\"Precipitation (mm)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ee.FeatureCollection.geetools.plot_hist\n", - "\n", - "The x-axis is defined by value bins for the range of values of a selected property; the y-axis is the number of elements in the given bin." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/prambaud/miniconda3/envs/geetools/lib/python3.11/site-packages/ee/deprecation.py:207: DeprecationWarning: \n", - "\n", - "Attention required for OREGONSTATE/PRISM/Norm81m! You are using a deprecated asset.\n", - "To ensure continued functionality, please update it.\n", - "Learn more: https://developers.google.com/earth-engine/datasets/catalog/OREGONSTATE_PRISM_Norm81m\n", - "\n", - " warnings.warn(warning, category=DeprecationWarning)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "# load some data\n", - "normClim = ee.ImageCollection('OREGONSTATE/PRISM/Norm81m').toBands()\n", - "\n", - "# Make a point sample of climate variables for a region in western USA.\n", - "region = ee.Geometry.Rectangle(-123.41, 40.43, -116.38, 45.14)\n", - "climSamp = normClim.sample(region, 5000)\n", - "\n", - "\n", - "# initialize the plot with the ecoregions data\n", - "ax = climSamp.geetools.plot_hist(\n", - " property = \"07_ppt\",\n", - " label = \"July Precipitation (mm)\",\n", - " color = '#1d6b99',\n", - " ax = ax,\n", - " bins = 30\n", - ")\n", - "\n", - "# once created the axes can be modified as needed using pure matplotlib functions\n", - "ax.set_title(\"July Precipitation Distribution for NW USA\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/index.rst b/docs/index.rst index 59634558..a5eb83d7 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -7,8 +7,8 @@ geetools .. toctree:: :hidden: + setup/index usage/index - example/index autoapi/index Changelogs earth-engine API @@ -32,24 +32,31 @@ content .. grid-item:: - .. card:: Usage - :link: usage/install.html + .. card:: :icon:`fa-solid fa-chart-simple` plot + :link: usage/plot/index.html - Usage and installation + Display EE objects directly as static plots. .. grid-item:: - .. card:: Contribute - :link: usage/contribute.html + .. card:: :icon:`fa-solid fa-folder` asset + :link: usage/asset.html - Help us improve the lib. + Manage your assets as a object-oriented file system. + + .. grid-item:: + + .. card:: :icon:`fa-solid fa-images` export ImageCollections + :link: usage/export.html + + Useful wrapper to export ImageCollections as simply as Images. .. grid-item:: - .. card:: API - :link: autoapi/index.html + .. card:: :icon:`fa-solid fa-handshake-angle` Contribute + :link: setup/contribute.html - Discover the lib API. + Help us improve the lib. Why using it ? -------------- diff --git a/docs/usage/author.rst b/docs/setup/author.rst similarity index 100% rename from docs/usage/author.rst rename to docs/setup/author.rst diff --git a/docs/usage/contribute.rst b/docs/setup/contribute.rst similarity index 100% rename from docs/usage/contribute.rst rename to docs/setup/contribute.rst diff --git a/docs/setup/index.rst b/docs/setup/index.rst new file mode 100644 index 00000000..9e54a1c1 --- /dev/null +++ b/docs/setup/index.rst @@ -0,0 +1,46 @@ +Setup +===== + +Overview +-------- + +The User Guide covers all of **geetools** by topic area. The :doc:`quickstart` page is a good place to start if you are new to the package or just want to refresh your memory. The :doc:`layout` page provides a high-level overview of the package's layout, and the :doc:`pattern` page provides a high-level overview of the package's design decsisions. + +The use of the package requires a basic understanding of the **Python** programming language and the **GEE Python API**. Users brand-new to Earth Engine should refer to the `Google documentation `__ first. + +Further hands-on example of specific tasks can be found in the :doc:`../usage/index` section. and for the most advance user please refe to the :doc:`../autoapi/index` section for a complete description of each individual functionality. + +Refactoring +----------- + +Since version v1.0.0, the package has been drastically modified to adopt the extension pattern (see :doc:`pattern` for more information). Many functions have also bee dropped or fully refactored to improve overall performances, and to make the package more consistent and easy to use. For more information about the miregation process please refer to the :doc:`migration` page. + +.. important:: + + The refactoring process is not finished yet, we will progressively reintegrate all the methods in the new pattern and add many cool functionalities. If any of your previous is not working anymore and the :doc:`migration` page did not provided any solution, please open an issue in the `GitHub repository `__. + +.. toctree:: + :hidden: + :caption: Get started + + install + quickstart + layout + +.. toctree:: + :hidden: + :caption: Extension Layout + + pattern + migration + inspiration + +.. toctree:: + :hidden: + :caption: Contributor guide + + contribute + author + license + + diff --git a/docs/usage/inspiration.rst b/docs/setup/inspiration.rst similarity index 100% rename from docs/usage/inspiration.rst rename to docs/setup/inspiration.rst diff --git a/docs/usage/install.rst b/docs/setup/install.rst similarity index 100% rename from docs/usage/install.rst rename to docs/setup/install.rst diff --git a/docs/usage/layout.rst b/docs/setup/layout.rst similarity index 100% rename from docs/usage/layout.rst rename to docs/setup/layout.rst diff --git a/docs/usage/license.rst b/docs/setup/license.rst similarity index 100% rename from docs/usage/license.rst rename to docs/setup/license.rst diff --git a/docs/usage/migration.rst b/docs/setup/migration.rst similarity index 100% rename from docs/usage/migration.rst rename to docs/setup/migration.rst diff --git a/docs/usage/pattern.rst b/docs/setup/pattern.rst similarity index 100% rename from docs/usage/pattern.rst rename to docs/setup/pattern.rst diff --git a/docs/usage/quickstart.rst b/docs/setup/quickstart.rst similarity index 98% rename from docs/usage/quickstart.rst rename to docs/setup/quickstart.rst index d9ea4961..d9cfc446 100644 --- a/docs/usage/quickstart.rst +++ b/docs/setup/quickstart.rst @@ -57,7 +57,7 @@ This small example shows how **geetools** is wrapping the excellent ``ee_extra`` .geetools.scaleAndOffset() # Extended (pre-processing) .geetools.spectralIndices(['NDVI','NDWI','BAIS2'])) # Extended (processing) -More examples of more complex and meaningful analysis can be found in the :doc:`../example/index` gallery. +More examples of more complex and meaningful analysis can be found in the :doc:`../usage/index` gallery. F401 ? ------ diff --git a/docs/usage/asset.ipynb b/docs/usage/asset.ipynb new file mode 100644 index 00000000..c718c60b --- /dev/null +++ b/docs/usage/asset.ipynb @@ -0,0 +1,625 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Object-oriented asset file system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee_community/geetools/blob/main/docs/example/asset.ipynb)\n", + "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee_community/geetools/blob/main/docs/example/asset.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import ee, pytest_gee, os\n", + "\n", + "if \"EARTHENGINE_SERVICE_ACCOUNT\" in os.environ:\n", + " pytest_gee.init_ee_from_service_account()\n", + "elif \"EARTHENGINE_PROJECT\" in os.environ:\n", + " pytest_gee.init_ee_from_token()\n", + "else:\n", + " raise ValueError(\"Cannot authenticate with Earth Engine.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up environment\n", + "\n", + "Install all the required libs if necessary and perform the import statements upstream." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if installation of libs is necessary\n", + "# !pip install earthengine-api geetools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ee\n", + "import geetools #noqa: F401" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if authetication to GEE is needed\n", + "# ee.Authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if initialization is required\n", + "# ee.Initialize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The `Asset` object\n", + "\n", + "In Google Earth Engine API, users are working with Assets. An asset is a filelike object that englobes a wide variety of types: IMAGE, IMAGE_COLLECTION, FOLDER, TABLE, FEATURE_COLLECTION, etc.\n", + "\n", + "They are identified by a unique ID, which is a string that looks like: `projects/username/assets/foo`. Using the vanila Earthengine API, They can be modified using the `ee.data` module. This module has been proven complicated when dealing with basic file manipulation operation such as listing, moving, copying, etc.\n", + "\n", + "`geetools` provides a simple way to manage assets as an object-oriented filesystem paths using the `Asset` object. This object is a subclass of the `pathlib.Path` object, which is a powerful way to manage file paths in Python. Most of the methods and properties are overwritten to work with the Google Earth Engine context.\n", + "\n", + "`ee.Asset` objects implement the os.PathLike interface, allowing them to be used anywhere the interface is accepted." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic use\n", + "\n", + "Importing the main class:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ee, geetools" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create asset objects \n", + "\n", + "The Asset objects etend the pathlib.Path object and thus behave exactly the same when dealing with constructor. THe only differnece is that asset path only supports posix-like file separator: `/`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ee.Asset(\"projects/ee-geetools/assets/documentation/image1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each element of pathsegments can be either a string representing a path segment, or an object implementing the os.PathLike interface where the __fspath__() method returns a string, such as another path object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ee.Asset(\"projects\", \"ee-geetools\", \"assets\", \"documentation\", \"image1\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ee.Asset(\"projects/ee-geetools/assets/documentation\") / \"image1\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ee.Asset(\"projects/ee-geetools/assets/documentation\").joinpath(\"image1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Listing subdirectories" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# a public folder created for this docuemntation\n", + "folder = ee.Asset(\"projects/ee-geetools/assets/documentation\")\n", + "\n", + "# list all its direct subdirectories\n", + "[a for a in folder.iterdir() if a.is_folder()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "- {py:meth}`iterdir `: {docstring}`geetools.Asset.iterdir`\n", + "- {py:meth}`is_folder `: {docstring}`geetools.Asset.is_folder`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Listing Image in this folder" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[a for a in folder.iterdir() if a.is_image()]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[a for a in folder.glob(\"**/image*\")]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "- {py:meth}`iterdir `: {docstring}`geetools.Asset.iterdir`\n", + "- {py:meth}`glob `: {docstring}`geetools.Asset.glob`\n", + "- {py:meth}`is_image `: {docstring}`geetools.Asset.is_image`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Querying asset properties" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "folder.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fakeImage = folder / \"image6\"\n", + "fakeImage.exists()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "- {py:meth}`exists `: {docstring}`geetools.Asset.exists`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## General properties\n", + "\n", + "Paths are immutable and hashable. Paths of a same flavour are comparable and orderable. These properties respect the flavour’s case-folding semantics:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "folder = ee.Asset(\"projects/ee-geetools/assets/documentation\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "folder == ee.Asset(\"projects/ee-geetools/assets/DOCUMENTATION\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "folder in { ee.Asset(\"projects/ee-geetools/assets/documentation\")}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The slash operator helps create child asset, like `os.path.join()`. If the argument is an absolute asset, the previous path is ignored." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ee.Asset(\"projects/ee-geetools/assets/documentation\") / \"image1\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An asset object can be used anywhere an object implementing `os.PathLike` is accepted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "a = ee.Asset(\"projects/ee-geetools/assets/documentation\")\n", + "os.fspath(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The string representation of an asset is the asset id itself, which you can pass to any function taking an asset id as a string:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/image1\")\n", + "str(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accessing individual parts\n", + "\n", + "To access the individual “parts” (components) of a path, use the following property:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/image1\")\n", + "a.parts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "- {py:meth}`parts `: {docstring}`geetools.Asset.parts`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### access parent container\n", + "\n", + "Asset parent containers can be access either by the `parent` property or the `parents` property. Note This is a purely lexical operation and the parent is not checked to exist.\n", + "\n", + "```{api}\n", + "- {py:meth}`parent `: {docstring}`geetools.Asset.parent`\n", + "- {py:meth}`parents `: {docstring}`geetools.Asset.parents`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.parent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.parents" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Name of the asset\n", + "\n", + "A string representing the final path component can be used to get the name of the asset.add\n", + "\n", + "```{api}\n", + "- {py:meth}`name `: {docstring}`geetools.Asset.name`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.name" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## General Methods\n", + "\n", + "Pure paths provide the following methods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### evaluate relation between assets\n", + "\n", + "It's possible to check if files are related between one another using the following methods:\n", + "\n", + "```{api}\n", + "- {py:meth}`is_relative_to `: {docstring}`geetools.Asset.is_relative_to`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "b = ee.Asset(\"projects/ee-geetools/assets/documentation\")\n", + "a.is_relative_to(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### create a siblings\n", + "\n", + "One can create a siblings asset in the same container by using the `with_name()` method:\n", + "\n", + "```{api} \n", + "- {py:meth}`with_name `: {docstring}`geetools.Asset.with_name`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.with_name(\"image2\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### resolve unix like symbols\n", + "\n", + "One can use some unix-like descriptors in it's Asset constructor parameters. If so before using the Asset object, it is necessary to resolve these symbols. The method `expanduser` does that.\n", + "\n", + "```{api}\n", + "- {py:meth}`expanduser `: {docstring}`geetools.Asset.expanduser`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"~/documentation/subfolder1/image1\")\n", + "a.expanduser()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### check existence\n", + "\n", + "One can check if an asset exists using the `exists` method:\n", + "\n", + "```{api}\n", + "- {py:meth}`exists `: {docstring}`geetools.Asset.exists`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image10\")\n", + "a.exists()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate asset type\n", + "\n", + "As Earth Engine is not using any file extention to differentiate the asset type, one can use the `is_type` method with any of the following types: `IMAGE`, `IMAGE_COLLECTION`, `FOLDER`, `TABLE`, `FEATURE_COLLECTION`, `UNKNOWN`.\n", + "\n", + "```{api}\n", + "- {py:meth}`is_type `: {docstring}`geetools.Asset.is_type`\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = ee.Asset(\"projects/ee-geetools/assets/documentation/subfolder1/image1\")\n", + "a.is_type(\"IMAGE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All type checks are available in dedicated wrapped methods like `is_image`, `is_folder`, `is_table` ...etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a.is_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many other useful methods are available and are described in the {py:class}`API documentation `." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geetools", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/export.ipynb b/docs/usage/export.ipynb new file mode 100644 index 00000000..7cb703b2 --- /dev/null +++ b/docs/usage/export.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exporting ImageCollections\n", + "\n", + "Earth Engine provides numbers of ways to export `ee.Image` as explained in their [documentation](https://developers.google.com/earth-engine/guides/image_export). `geetools`provides an extention to the `ee.Export` class to export `ee.ImageCollection` as well. This is useful when you have a collection of images and you want to export them all at once.\n", + "\n", + "As the vanilla Earth Engine methods were returning Task objects, these method will return lists of Task objects. This ensures that Once the task are launched they can be fully monitored outside from your initial script." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee_community/geetools/blob/main/docs/example/export.ipynb)\n", + "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee_community/geetools/blob/main/docs/example/export.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import ee, pytest_gee, os\n", + "\n", + "if \"EARTHENGINE_SERVICE_ACCOUNT\" in os.environ:\n", + " pytest_gee.init_ee_from_service_account()\n", + "elif \"EARTHENGINE_PROJECT\" in os.environ:\n", + " pytest_gee.init_ee_from_token()\n", + "else:\n", + " raise ValueError(\"Cannot authenticate with Earth Engine.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Set up \n", + "\n", + "Start by defining the image data that will be exported." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ee, geetools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load a landsat image and select three bands over the whole mont of january 2023\n", + "landsat = (\n", + " ee.ImageCollection(\"LANDSAT/LC08/C02/T1_TOA\")\n", + " .select(['B4', 'B3', 'B2'])\n", + " .filterDate('2023-01-01', '2023-01-31')\n", + ")\n", + "\n", + "# Create a geometry representing an export region.\n", + "geometry = ee.Geometry.Rectangle([116.2621, 39.8412, 116.4849, 40.01236])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## to Drive\n", + "\n", + "To export an imageCollection to your Drive account, use `ee.batch.Export.geetools.imagecollection.toDrive()`. For example, to export portions of a Landsat collection, define a region to export, then call Export:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python \n", + "# Export the image to Cloud Storage.\n", + "ee.batch.Export.geetools.imagecollection.toDrive(\n", + " imagecollection = landsat,\n", + " index_property = \"system:id\",\n", + " description = 'imageCollectionToDriveExample',\n", + " scale = 30,\n", + " region = geometry,\n", + " folder = 'geetools_example',\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When this code is run, a list of export task will be created you will need to `start` them to start the export computation in the server." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## to Cloud Storage\n", + "\n", + "To export an ImageCollection to a Google Cloud Storage bucket, use `ee.batch.Export.geetools.imagecollection.toCloudStorage()`. To export the Landsat image in the previous example to Cloud Storage instead of Drive, use:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python \n", + "# Export the image to Cloud Storage.\n", + "ee.batch.Export.image.toCloudStorage(\n", + " imagecollection = landsat,\n", + " index_property = \"system:id\",\n", + " description = 'imageToCloudExample',\n", + " bucket = 'your-bucket-name',\n", + " scale = 30,\n", + " region = geometry\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When this code is run, a list of export task will be created you will need to `start` them to start the export computation in the server." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## To Asset\n", + "\n", + "To export an ImageCollection to an Earth Engine asset, use `ee.batch.Export.geetools.imagecollection.toAsset()`. To export the Landsat image in the previous example to an asset, use:\n", + "\n", + "When this code is run, a list of export task will be created you will need to `start` them to start the export computation in the server." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "# Start the export process.\n", + "ee.batch.Export.geetools.imagecollection.toAsset(\n", + " imagecollection = landsat,\n", + " index_property = \"system:id\",\n", + " assetId = 'projects/username/ladnsat_collection',\n", + " scale = 30,\n", + " region = geometry,\n", + " maxPixels = 1e13,\n", + " pyramidingPolicy = {\n", + " 'b4': 'mean',\n", + " 'b3': 'mean',\n", + " 'b2': 'mean'\n", + " }\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For all function please refer to offcial documentation for complete list of parameters of the `ee.batch.Export.image` methods." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/index.rst b/docs/usage/index.rst index 75f60450..f595fc84 100644 --- a/docs/usage/index.rst +++ b/docs/usage/index.rst @@ -1,46 +1,45 @@ -User guide -========== +Usage +===== Overview -------- -The User Guide covers all of **geetools** by topic area. The :doc:`quickstart` page is a good place to start if you are new to the package or just want to refresh your memory. The :doc:`layout` page provides a high-level overview of the package's layout, and the :doc:`pattern` page provides a high-level overview of the package's design decsisions. +This section gathered many real life examples of the Lib usage gathered by the community. +If you think your workflow should be shared please open a PR and follow the contribution guildelines shared in the next section. -The use of the package requires a basic understanding of the **Python** programming language and the **GEE Python API**. Users brand-new to Earth Engine should refer to the `Google documentation `__ first. +.. warning:: -Further hands-on example of specific tasks can be found in the :doc:`../example/index` section. and for the most advance user please refe to the :doc:`../autoapi/index` section for a complete description of each individual functionality. + The example gallery is a work in progress as the library was recently refactored. + All contributions are welcolmed! -Refactoring ------------ +Add a new example +----------------- -Since version v1.0.0, the package has been drastically modified to adopt the extension pattern (see :doc:`pattern` for more information). Many functions have also bee dropped or fully refactored to improve overall performances, and to make the package more consistent and easy to use. For more information about the miregation process please refer to the :doc:`migration` page. +.. image:: /_static/we-need-you.jpg + :alt: We need you! + :align: center -.. important:: +Currently most of the examples built by `@Rodrigo `__ are still using the old implementation of the library. +They should be transformed into modern example and moved from the old `notebook `__ folder to the new `example `__ one to be displayed in our doc. - The refactoring process is not finished yet, we will progressively reintegrate all the methods in the new pattern and add many cool functionalities. If any of your previous is not working anymore and the :doc:`migration` page did not provided any solution, please open an issue in the `GitHub repository `__. +The examples are regular notebook files that are interpreted by the ``myst-nb`` lib and displayed in the doc, clicking on the :guilabel:`open in colab` button will open a colab notebook with the code ready to be executed and the :guilabel:`view source` will bring you back to github. -.. toctree:: - :hidden: - :caption: Get started +To add a new example, you can use the `example template `__ and replace things with your code. - install - quickstart - layout +Adapt the code of the 2 first buttons to your file so users can lunch it in collab and view the source in github. -.. toctree:: - :hidden: - :caption: Extension Layout +.. code-block:: md - pattern - migration - inspiration + [![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee_community/geetools/blob/main/docs/example/template.ipynb) + [![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee_community/gee_tools/blob/main/docs/example/template.ipynb) -.. toctree:: - :hidden: - :caption: Contributor guide - contribute - author - license +Then you can open a PR with the new file and it will be reviewed and merged. +.. toctree:: + :hidden: + template + export + plot/index + asset \ No newline at end of file diff --git a/docs/usage/plot/index.rst b/docs/usage/plot/index.rst new file mode 100644 index 00000000..e55d7878 --- /dev/null +++ b/docs/usage/plot/index.rst @@ -0,0 +1,12 @@ +Plotting +======== + +We embed some plotting capabilities in the library to help you visualize your data. + +.. toctree:: + + plot-featurecollection + plot-image + plot-imagecollection + map-image + map-featurecollection \ No newline at end of file diff --git a/docs/usage/plot/map-featurecollection.ipynb b/docs/usage/plot/map-featurecollection.ipynb new file mode 100644 index 00000000..0dd03fa9 --- /dev/null +++ b/docs/usage/plot/map-featurecollection.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Map FeatureCollection\n", + "\n", + "The `geetools` extension contains a set of functions for rendering maps from `ee.FeatureCollection` objects. Use the following function descriptions and examples to determine the best function and chart type for your purpose." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import ee, pytest_gee, os\n", + "\n", + "if \"EARTHENGINE_SERVICE_ACCOUNT\" in os.environ:\n", + " pytest_gee.init_ee_from_service_account()\n", + "elif \"EARTHENGINE_PROJECT\" in os.environ:\n", + " pytest_gee.init_ee_from_token()\n", + "else:\n", + " raise ValueError(\"Cannot authenticate with Earth Engine.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee-community/geetools/blob/main/docs/usage/map-featurecollection.ipynb)\n", + "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee-community/geetools/blob/main/docs/usage/map-featurecollection.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up environment\n", + "\n", + "Install all the required packages and perform the import statement upstream." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if installation of libs is necessary\n", + "# !pip install earthengine-api geetools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import display\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import ee\n", + "import geetools #noqa: F401" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if authetication to GEE is needed\n", + "# ee.Authenticate()\n", + "# ee.Intialize(project=\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example data \n", + "\n", + "The following examples rely on a `ee.FeatureCollection` composed of all the hydroshed bassins from south america." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "region = ee.Geometry.BBox(-80, -60, -20, 20);\n", + "fc = ee.FeatureCollection('WWF/HydroATLAS/v1/Basins/level04').filterBounds(region)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Map Vector\n", + "\n", + "```{api}\n", + "{py:meth}`plot `: {docstring}`geetools.FeatureCollectionAccessor.plot`\n", + "```\n", + "\n", + "An `ee.FeatureCollection` is a vector representation of geographical properties. A user can be interested by either the property evolution across the landscape or the geometries associated with it. The {py:meth}`plot ` is coverinig both use cases. \n", + "\n", + "### Map a property\n", + "\n", + "A single property can be ploted on a map using matplotlib. The following example is showing the bassin area in km².\n", + "\n", + "First create a matplotlib figure and axis:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.ioff() # remove interactive for the sake of the example\n", + "fig, ax = plt.subplots(figsize=(10, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can add the bassins to the map using the `plot` method. By default it will display the first property of the features. In our case we will opt to display the area of the bassins in km² i.e. the \"UP_AREA\" property." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fc.geetools.plot(ax=ax, property=\"UP_AREA\", cmap=\"viridis\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the plot, we can customize it with matplotlib. For example, we can add a title and a colorbar." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# you can then customize the figure as you would for any other matplotlib object\n", + "fig.colorbar(ax.collections[0], label=\"Upstream area (km²)\")\n", + "ax.set_title(\"HydroATLAS basins of level4\")\n", + "ax.set_xlabel(\"Longitude (°)\")\n", + "ax.set_ylabel(\"Latitude (°)\")\n", + "\n", + "display(fig)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map geometries\n", + "\n", + "Alternatively if you only want to plot the geometries of the featurecollection on a map, you can use the `plot` method with the `boundares` parameter set to `True`.\n", + "\n", + "Similarly to the previous example we start by creating a pyplot figure and axis:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.ioff() # remove interactive for the sake of the example\n", + "fig, ax = plt.subplots(figsize=(10, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can start plotting the geometries:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fc.geetools.plot(ax=ax, boundaries=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and finally customize the plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# you can then customize the figure as you would for any other matplotlib object\n", + "ax.set_title(\"Borders of the HydroATLAS basins of level4\")\n", + "ax.set_xlabel(\"Longitude (°)\")\n", + "ax.set_ylabel(\"Latitude (°)\")\n", + "\n", + "display(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geetools", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/plot/map-image.ipynb b/docs/usage/plot/map-image.ipynb new file mode 100644 index 00000000..4348963d --- /dev/null +++ b/docs/usage/plot/map-image.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Map Image\n", + "\n", + "The `geetools` extension contains a set of functions for rendering maps from `ee.Image` objects. Use the following function descriptions and examples to determine the best function and chart type for your purpose." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import ee, pytest_gee, os\n", + "\n", + "if \"EARTHENGINE_SERVICE_ACCOUNT\" in os.environ:\n", + " pytest_gee.init_ee_from_service_account()\n", + "elif \"EARTHENGINE_PROJECT\" in os.environ:\n", + " pytest_gee.init_ee_from_token()\n", + "else:\n", + " raise ValueError(\"Cannot authenticate with Earth Engine.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee-community/geetools/blob/main/docs/usage/map-image.ipynb)\n", + "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee-community/geetools/blob/main/docs/usage/map-image.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up environment\n", + "\n", + "Install the required packages and authenticate your Earth Engine account." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if installation of libs is necessary\n", + "# !pip install earthengine-api geetools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import display\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import ee\n", + "import geetools #noqa: F401" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if authetication to GEE is needed\n", + "# ee.Authenticate()\n", + "# ee.Intialize(project=\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example data \n", + "\n", + "The following examples rely on the \"COPERNICUS/S2_HARMONIZED\" `ee.ImageCollection` filtered between 2022-06-01 and 2022-06-30. We then build the NDVI spectral indice and use mosaic to get an `ee.Image` object. This object is clipped over the Vatican city as it's one of the smallest country in the world." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# load the vatican\n", + "level0 = ee.FeatureCollection(\"FAO/GAUL/2015/level0\")\n", + "vatican = level0.filter(ee.Filter.eq(\"ADM0_NAME\", \"Holy See\"))\n", + "\n", + "# pre-process the imagecollection and mosaic the month of June 2022\n", + "image = (\n", + " ee.ImageCollection('COPERNICUS/S2_HARMONIZED')\n", + " .filterDate('2022-06-01', '2022-06-30')\n", + " .filterBounds(vatican)\n", + " .geetools.maskClouds()\n", + " .geetools.spectralIndices(\"NDVI\")\n", + " .mosaic()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Map Raster\n", + "\n", + "```{api}\n", + "{py:meth}`plot `: \n", + " {docstring}`geetools.ImageAccessor.plot`\n", + "```\n", + "\n", + "An `ee.image` is a raster representation of the Earth's surface. The `plot` function allows you to visualize the raster data on a map. The function provides options to customize the visualization, such as the color palette, opacity, and the visualization range.\n", + "\n", + "### Map pseudo color\n", + "\n", + "A pseudo-color image is a single-band raster image that uses a color palette to represent the data. The following example demonstrates how to plot the NDVI pseudo-color image using the `plot` function.\n", + "\n", + "First create a matplotlib figure and axis: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.ioff() # remove interactive for the sake of the example\n", + "fig, ax = plt.subplots()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can add the map to the axis. Provide a single element list in the bands parameter to plot the NDVI image. \n", + "As per interactive representation an image needs to be reduced to a region, here \"Vatican City\". In this example we also select a pseudo-mercator projection and we displayed the `ee.FeatureCollection` on top of it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "image.geetools.plot(\n", + " bands = [\"NDVI\"],\n", + " ax=ax,\n", + " region=vatican.geometry(),\n", + " crs=\"EPSG:3857\",\n", + " scale=10,\n", + " fc=vatican,\n", + " cmap=\"viridis\",\n", + " color=\"k\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the plot, we can customize it with matplotlib. For example, we can add a title and a colorbar." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# as it's a figure you can then edit the information as you see fit\n", + "ax.set_title(\"NDVI in Vatican City\")\n", + "ax.set_xlabel(\"x coordinates (m)\")\n", + "ax.set_ylabel(\"y coordinates (m)\")\n", + "fig.colorbar(ax.images[0], label=\"NDVI\")\n", + "\n", + "display(fig)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Map RGB combo\n", + "\n", + "An RGB image is a three-band raster image that uses the red, green, and blue bands to represent the data. The following example demonstrates how to plot the RGB image using the `plot` function.\n", + "\n", + "First create a matplotlib figure and axis: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.ioff() # remove interactive for the sake of the example\n", + "fig, ax = plt.subplots()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can add the map to the axis. Provide a 3 elements list in the bands parameter to plot the NDVI image. \n", + "As per interactive representation an image needs to be reduced to a region, here \"Vatican City\". In this example we displayed the `ee.FeatureCollection` on top of it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "image.geetools.plot(\n", + " bands = [\"B4\", \"B3\", \"B2\"],\n", + " ax=ax,\n", + " region=vatican.geometry(),\n", + " fc=vatican,\n", + " color=\"k\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and finally customize the plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# as it's a figure you can then edit the information as you see fit\n", + "ax.set_title(\"Sentinel 2 composite in Vatican City\")\n", + "ax.set_xlabel(\"longitude (°)\")\n", + "ax.set_ylabel(\"latitude (°)\")\n", + "\n", + "display(fig)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geetools", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/plot/plot-featurecollection.ipynb b/docs/usage/plot/plot-featurecollection.ipynb new file mode 100644 index 00000000..bd61f7c9 --- /dev/null +++ b/docs/usage/plot/plot-featurecollection.ipynb @@ -0,0 +1,583 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot FeatureCollection\n", + "\n", + "The `geetools` extension contains a set of functions for rendering charts from `ee.FeatureCollection` objects. The choice of function determines the arrangement of data in the chart, i.e., what defines x- and y-axis values and what defines the series. Use the following function descriptions and examples to determine the best function and chart type for your purpose." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![github](https://img.shields.io/badge/-see%20sources-white?logo=github&labelColor=555)](https://github.com/gee-community/geetools/blob/main/docs/usage/plot-featurecollection.ipynb)\n", + "[![colab](https://img.shields.io/badge/-open%20in%20colab-blue?logo=googlecolab&labelColor=555)](https://colab.research.google.com/github/gee-community/geetools/blob/main/docs/usage/plot-featurecollection.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import ee, pytest_gee, os\n", + "\n", + "if \"EARTHENGINE_SERVICE_ACCOUNT\" in os.environ:\n", + " pytest_gee.init_ee_from_service_account()\n", + "elif \"EARTHENGINE_PROJECT\" in os.environ:\n", + " pytest_gee.init_ee_from_token()\n", + "else:\n", + " raise ValueError(\"Cannot authenticate with Earth Engine.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up environment\n", + "\n", + "Install all the required libs if necessary and perform the import statements upstream." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if installation of libs is necessary\n", + "# !pip install earthengine-api geetools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "import ee\n", + "import geetools #noqa: F401" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# uncomment if authetication to GEE is needed\n", + "# ee.Authenticate()\n", + "# ee.Intialize(project=\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example data\n", + "\n", + "The following examples rely on a FeatureCollection composed of three ecoregion features with properties that describe climate normals." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import the example feature collection.\n", + "ecoregions = ee.FeatureCollection('projects/google/charts_feature_example')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot by features\n", + "\n", + "Features are plotted along the x-axis by values of a selected property. Series are defined by a list of property names whose values are plotted along the y-axis. The type of produced chart can be controlled by the `type` parameter as shown in the following examples.\n", + "\n", + "If you want to use another plotting library you can get the raw data using the `byFeatures` function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Data for the chart\n", + "features = ['f1', 'f2', 'f3']\n", + "p1_values = [0.5, 2.5, 4.5]\n", + "p2_values = [1.5, 3.5, 5.5]\n", + "p3_values = [2.5, 4.0, 6.5]\n", + "\n", + "# Set the width of the bars\n", + "bar_width = 0.25\n", + "index = np.arange(len(features))\n", + "offset = 0.005\n", + "\n", + "# Create the plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# Plotting the bars\n", + "rects1 = ax.bar(index, p1_values, bar_width, label='p1', color='#1d6b99')\n", + "rects2 = ax.bar(index + (bar_width + offset), p2_values, bar_width, label='p2', color='#cf513e')\n", + "rects3 = ax.bar(index + 2 * (bar_width + offset), p3_values, bar_width, label='p3', color='#f0af07')\n", + "\n", + "# Add labels, title, and custom x-axis tick labels\n", + "ax.set_xlabel('Features by property value')\n", + "ax.set_ylabel('Series property value')\n", + "ax.set_xticks(index + bar_width)\n", + "ax.set_xticklabels(features)\n", + "\n", + "# Add a legend\n", + "ax.legend(loc='upper center', bbox_to_anchor=(0.85, 1.15), ncol=3, title='Property names')\n", + "\n", + "# set the grid display\n", + "ax.grid(axis=\"y\")\n", + "ax.set_axisbelow(True)\n", + "ax.spines[\"top\"].set_visible(False)\n", + "ax.spines[\"right\"].set_visible(False)\n", + "\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "- {py:meth}`plot_by_features `: {docstring}`geetools.FeatureCollectionAccessor.plot_by_features`\n", + "- {py:meth}`byFeatures `: {docstring}`geetools.FeatureCollectionAccessor.byFeatures`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Column chart\n", + "\n", + "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by adjacent columns defined by a list of property names whose values are plotted along the y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize the plot with the ecoregions data\n", + "ecoregions.geetools.plot_by_features(\n", + " type = \"bar\",\n", + " featureId = \"label\",\n", + " properties = ['01_tmean', '02_tmean', '03_tmean', '04_tmean', '05_tmean', '06_tmean', '07_tmean', '08_tmean', '09_tmean', '10_tmean', '11_tmean', '12_tmean'],\n", + " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", + " colors = ['#604791', '#1d6b99', '#39a8a7', '#0f8755', '#76b349', '#f0af07', '#e37d05', '#cf513e', '#96356f', '#724173', '#9c4f97', '#696969'],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Temperature by Ecoregion\")\n", + "ax.set_xlabel(\"Ecoregion\")\n", + "ax.set_ylabel(\"Temperature (°C)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stacked column chart\n", + "\n", + "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by stacked columns defined by a list of property names whose values are plotted along the y-axis as the cumulative series sum." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ecoregions.geetools.plot_by_features(\n", + " type = \"stacked\",\n", + " featureId = \"label\",\n", + " properties = ['01_ppt', '02_ppt', '03_ppt', '04_ppt', '05_ppt', '06_ppt', '07_ppt', '08_ppt', '09_ppt', '10_ppt', '11_ppt', '12_ppt'],\n", + " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", + " colors = ['#604791', '#1d6b99', '#39a8a7', '#0f8755', '#76b349', '#f0af07', '#e37d05', '#cf513e', '#96356f', '#724173', '#9c4f97', '#696969'],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", + "ax.set_xlabel(\"Ecoregion\")\n", + "ax.set_ylabel(\"Precipitation (mm)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scatter chart\n", + "\n", + "Features are plotted along the x-axis, labeled by values of a selected property. Series are represented by points defined by a list of property names whose values are plotted along the y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ecoregions.geetools.plot_by_features(\n", + " type = \"scatter\",\n", + " featureId = \"label\",\n", + " properties = ['01_ppt', '06_ppt', '09_ppt'],\n", + " labels = [\"jan\", \"jun\", \"sep\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", + "ax.set_xlabel(\"Ecoregion\")\n", + "ax.set_ylabel(\"Precipitation (mm)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pie chart\n", + "\n", + "The pie is a property, each slice is the share from each feature whose value is cast as a percentage of the sum of all values of features composing the pie." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ecoregions.geetools.plot_by_features(\n", + " type = \"pie\",\n", + " featureId = \"label\",\n", + " properties = ['06_ppt'],\n", + " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Share of precipitation in June by Ecoregion\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Donut chart\n", + "\n", + "The donut is a property, each slice is the share from each feature whose value is cast as a percentage of the sum of all values of features composing the donut." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ecoregions.geetools.plot_by_features(\n", + " type = \"donut\",\n", + " featureId = \"label\",\n", + " properties = ['07_ppt'],\n", + " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Share of precipitation in July by Ecoregion\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot by properties\n", + "\n", + "Feature properties are plotted along the x-axis by name; values of the given properties are plotted along the y-axis. Series are features labeled by values of a selected property. The type of produced chart can be controlled by the `type` parameter as shown in the following examples." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Data for the chart\n", + "features = ['p1', 'p2', 'p3']\n", + "p1_values = [0.5, 2.5, 4.5]\n", + "p2_values = [1.5, 3.5, 5.5]\n", + "p3_values = [2.5, 4.0, 6.5]\n", + "\n", + "# Set the width of the bars\n", + "bar_width = 0.25\n", + "index = np.arange(len(features))\n", + "offset = 0.005\n", + "\n", + "# Create the plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# Plotting the bars\n", + "rects1 = ax.bar(index, p1_values, bar_width, label='f1', color='#1d6b99')\n", + "rects2 = ax.bar(index + (bar_width + offset), p2_values, bar_width, label='f2', color='#cf513e')\n", + "rects3 = ax.bar(index + 2 * (bar_width + offset), p3_values, bar_width, label='f3', color='#f0af07')\n", + "\n", + "# Add labels, title, and custom x-axis tick labels\n", + "ax.set_xlabel('Property names')\n", + "ax.set_ylabel('Series property value')\n", + "ax.set_xticks(index + bar_width)\n", + "ax.set_xticklabels(features)\n", + "\n", + "# Add a legend\n", + "ax.legend(loc='upper center', bbox_to_anchor=(0.85, 1.15), ncol=3, title='Features by property value')\n", + "\n", + "# set the grid display\n", + "ax.grid(axis=\"y\")\n", + "ax.set_axisbelow(True)\n", + "ax.spines[\"top\"].set_visible(False)\n", + "ax.spines[\"right\"].set_visible(False)\n", + "\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{api}\n", + "{py:meth}`plot_by_properties `: {docstring}`geetools.FeatureCollectionAccessor.plot_by_properties`\n", + "{py:meth}`byProperties `: {docstring}`geetools.FeatureCollectionAccessor.byProperties`\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Column chart\n", + "\n", + "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by columns, labeled by values of a selected property." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ax = ecoregions.geetools.plot_by_properties(\n", + " type = \"bar\",\n", + " properties = ['01_ppt', '02_ppt', '03_ppt', '04_ppt', '05_ppt', '06_ppt', '07_ppt', '08_ppt', '09_ppt', '10_ppt', '11_ppt', '12_ppt'],\n", + " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", + " featureId = \"label\",\n", + " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", + "ax.set_xlabel(\"Month\")\n", + "ax.set_ylabel(\"Precipitation (mm)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Line chart\n", + "\n", + "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by columns, labeled by values of a selected property." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize theplot with the ecoregions data\n", + "ax = ecoregions.geetools.plot_by_properties(\n", + " type = \"plot\",\n", + " properties = [\"01_ppt\", \"02_ppt\", \"03_ppt\", \"04_ppt\", \"05_ppt\", \"06_ppt\", \"07_ppt\", \"08_ppt\", \"09_ppt\", \"10_ppt\", \"11_ppt\", \"12_ppt\"],\n", + " featureId = \"label\",\n", + " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", + " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", + "ax.set_xlabel(\"Month\")\n", + "ax.set_ylabel(\"Precipitation (mm)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Area chart \n", + "\n", + "Feature properties are plotted along the x-axis, labeled and sorted by a dictionary input; the values of the given properties are plotted along the y-axis. Series are features, represented by lines and shaded areas, labeled by values of a selected property." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# initialize the plot with the ecoregions data\n", + "ax = ecoregions.geetools.plot_by_properties(\n", + " type = \"fill_between\",\n", + " properties = [\"01_ppt\", \"02_ppt\", \"03_ppt\", \"04_ppt\", \"05_ppt\", \"06_ppt\", \"07_ppt\", \"08_ppt\", \"09_ppt\", \"10_ppt\", \"11_ppt\", \"12_ppt\"],\n", + " labels = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", + " featureId = \"label\",\n", + " colors = [\"#f0af07\", \"#0f8755\", \"#76b349\"],\n", + " ax = ax\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"Average Monthly Precipitation by Ecoregion\")\n", + "ax.set_xlabel(\"Month\")\n", + "ax.set_ylabel(\"Precipitation (mm)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot hist\n", + "\n", + "```{api}\n", + "{py:meth}`plot_hist `: {docstring}`geetools.FeatureCollectionAccessor.plot_hist`\n", + "```\n", + "\n", + "The x-axis is defined by value bins for the range of values of a selected property; the y-axis is the number of elements in the given bin." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "\n", + "# load some data\n", + "normClim = ee.ImageCollection('OREGONSTATE/PRISM/Norm91m').toBands()\n", + "\n", + "# Make a point sample of climate variables for a region in western USA.\n", + "region = ee.Geometry.Rectangle(-123.41, 40.43, -116.38, 45.14)\n", + "climSamp = normClim.sample(region, 5000)\n", + "\n", + "\n", + "# initialize the plot with the ecoregions data\n", + "ax = climSamp.geetools.plot_hist(\n", + " property = \"07_ppt\",\n", + " label = \"July Precipitation (mm)\",\n", + " color = '#1d6b99',\n", + " ax = ax,\n", + " bins = 30\n", + ")\n", + "\n", + "# once created the axes can be modified as needed using pure matplotlib functions\n", + "ax.set_title(\"July Precipitation Distribution for NW USA\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/plot/plot-image.ipynb b/docs/usage/plot/plot-image.ipynb new file mode 100644 index 00000000..a8032e0c --- /dev/null +++ b/docs/usage/plot/plot-image.ipynb @@ -0,0 +1,27 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot Image\n", + "\n", + "```{warning}\n", + "This notebook is a work in progress. It is not yet functional.\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/usage/plot/plot-imagecollection.ipynb b/docs/usage/plot/plot-imagecollection.ipynb new file mode 100644 index 00000000..7e7326f8 --- /dev/null +++ b/docs/usage/plot/plot-imagecollection.ipynb @@ -0,0 +1,27 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot ee.ImageCollection\n", + "\n", + "```{warning}\n", + "This notebook is a work in progress. It is not yet functional.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/example/template.ipynb b/docs/usage/template.ipynb similarity index 100% rename from docs/example/template.ipynb rename to docs/usage/template.ipynb diff --git a/geetools/Asset.py b/geetools/Asset.py index 2c3cd355..b42059d0 100644 --- a/geetools/Asset.py +++ b/geetools/Asset.py @@ -1,6 +1,7 @@ """An Asset management class mimicking the ``pathlib.Path`` class behaviour.""" from __future__ import annotations +import os import re from pathlib import PurePosixPath from typing import Optional @@ -13,7 +14,7 @@ @_register_extention(ee) -class Asset: +class Asset(os.PathLike): """An Asset management class mimicking the ``pathlib.Path`` class behaviour.""" def __init__(self, *args): @@ -65,6 +66,14 @@ def __idiv__(self, other: pathlike) -> Asset: """Override the in-place division operator to join the asset with other paths.""" return Asset(self._path / str(other)) + def __fspath__(self): + """Implement the os.Pathlike interface.""" + return self.as_posix() + + def __hash__(self): + """make the Asset object hashable.""" + return hash(self.as_posix()) + @classmethod def home(cls) -> Asset: """Return the root asset folder of the used cloud project. @@ -439,6 +448,10 @@ def iterdir(self, recursive: bool = False) -> list: Args: recursive: If True, get all the children recursively. Defaults to False. + See Also: + - :py:meth:`glob `: :docstring:`geetools.Asset.glob` + - :py:meth:`rglob `: :docstring:`geetools.Asset.rglob` + Examples: .. code-block:: python @@ -682,6 +695,10 @@ def glob(self, pattern: str) -> list: Args: pattern: The pattern to match with the asset name. + See Also: + - :py:meth:`iterdir `: :docstring:`geetools.Asset.iterdir` + - :py:meth:`glob `: :docstring:`geetools.Asset.rglob` + Examples: .. code-block:: python @@ -696,6 +713,10 @@ def rglob(self, pattern: str) -> list: Args: pattern: The pattern to match with the asset name. + See Also: + - :py:meth:`glob `: :docstring:`geetools.Asset.glob` + - :py:meth:`iterdir `: :docstring:`geetools.Asset.iterdir` + Examples: .. code-block:: python diff --git a/geetools/FeatureCollection.py b/geetools/FeatureCollection.py index d839f380..cd185079 100644 --- a/geetools/FeatureCollection.py +++ b/geetools/FeatureCollection.py @@ -152,6 +152,10 @@ def byProperties( Returns: A dictionary with all the properties as keys and their values in each feaure as a list. + See Also: + - :py:meth:`byFeatures `: :docstring:`geetools.FeatureCollectionAccessor.byFeatures` + - :py:meth:`plot_by_properties `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_properties` + Example: .. code-block:: python @@ -204,6 +208,10 @@ def byFeatures( Returns: A dictionary with all the feature ids as keys and their properties as a dictionary. + See Also: + - :py:meth:`byProperties `: :docstring:`geetools.FeatureCollectionAccessor.byProperties` + - :py:meth:`plot_by_features `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_features` + Examples: .. code-block:: python @@ -249,6 +257,9 @@ def plot_by_features( If no ``properties`` are provided, all properties will be plotted. If no ``featureId`` is provided, the "system:index" property will be used. + Warning: + This function is a client-side function. + Args: type: The type of plot to use. Defaults to "bar". can be any type of plot from the python lib `matplotlib.pyplot`. If the one you need is missing open an issue! featureId: The property to use as the x-axis (name the features). Defaults to "system:index". @@ -258,6 +269,12 @@ def plot_by_features( ax: The matplotlib axes to use. If not provided, the plot will be send to a new figure. kwargs: Additional arguments from the ``pyplot`` function. + See Also: + - :py:meth:`byFeatures `: :docstring:`geetools.FeatureCollectionAccessor.byFeatures` + - :py:meth:`plot_by_properties `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_properties` + - :py:meth:`plot_hist `: :docstring:`geetools.FeatureCollectionAccessor.plot_hist` + - :py:meth:`plot `: :docstring:`geetools.FeatureCollectionAccessor.plot` + Examples: .. code-block:: python @@ -265,9 +282,6 @@ def plot_by_features( fc = ee.FeatureCollection("FAO/GAUL/2015/level2").limit(10) fc.geetools.plot_by_features(properties=["ADM1_CODE", "ADM2_CODE"]) - - Note: - This function is a client-side function. """ # Get the features and properties props = ee.List(properties) if properties else self._obj.first().propertyNames().getInfo() @@ -298,6 +312,9 @@ def plot_by_properties( Each features will be represented by a color and each property will be a bar of the bar chart. + Warning: + This function is a client-side function. + Args: type: The type of plot to use. Defaults to "bar". can be any type of plot from the python lib `matplotlib.pyplot`. If the one you need is missing open an issue! featureId: The property to use as the y-axis (name the features). Defaults to "system:index". @@ -307,6 +324,12 @@ def plot_by_properties( ax: The matplotlib axes to use. If not provided, the plot will be send to a new figure. kwargs: Additional arguments from the ``pyplot`` function. + See Also: + - :py:meth:`byProperties `: :docstring:`geetools.FeatureCollectionAccessor.byProperties` + - :py:meth:`plot_by_features `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_features` + - :py:meth:`plot_hist `: :docstring:`geetools.FeatureCollectionAccessor.plot_hist` + - :py:meth:`plot `: :docstring:`geetools.FeatureCollectionAccessor.plot` + Examples: .. code-block:: python @@ -314,9 +337,6 @@ def plot_by_properties( fc = ee.FeatureCollection("FAO/GAUL/2015/level2").limit(10) fc.geetools.plot_by_properties(xProperties=["ADM1_CODE", "ADM2_CODE"]) - - Note: - This function is a client-side function. """ # Get the features and properties fc = self._obj @@ -339,6 +359,9 @@ def plot_hist( ) -> Axes: """Plot the histogram of a specific property. + Warning: + This function is a client-side function. + Args: property: The property to display label: The label to use for the property. If not provided, the property name will be used. @@ -346,6 +369,11 @@ def plot_hist( color: The color to use for the plot. If not provided, the default colors from the matplotlib library will be used. kwargs: Additional arguments from the ``pyplot.hist`` function. + See Also: + - :py:meth:`plot_by_features `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_features` + - :py:meth:`plot_by_properties `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_properties` + - :py:meth:`plot `: :docstring:`geetools.FeatureCollectionAccessor.plot` + Examples: .. code-block:: python @@ -528,6 +556,9 @@ def plot( ): """Plot the featureCollection on a map using the provided property. + Warning: + This function is a client-side function. + Parameters: property: The property to use to color the features. ax: The axes to plot the map on. @@ -536,6 +567,11 @@ def plot( boundaries: Whether to plot the features values or only the boundaries. color: The color to use for the boundaries. + See Also: + - :py:meth:`plot_by_features `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_features` + - :py:meth:`plot_by_properties `: :docstring:`geetools.FeatureCollectionAccessor.plot_by_properties` + - :py:meth:`plot_hist `: :docstring:`geetools.FeatureCollectionAccessor.plot_hist` + Examples: .. code-block:: python diff --git a/geetools/Image.py b/geetools/Image.py index 97a55666..8ab03c44 100644 --- a/geetools/Image.py +++ b/geetools/Image.py @@ -1365,6 +1365,7 @@ def plot( cmap: str = "viridis", crs: str = "EPSG:4326", scale: float = 0.0001, # 0.0001 is the default scale for Sentinel-2 + color="k", ): """Plot the image on a matplotlib axis. @@ -1376,6 +1377,7 @@ def plot( cmap: The colormap to use for the image. Default is 'viridis'. can only ber used for single band images. crs: The coordinate reference system of the image. scale: The scale of the image. + color: The color of the overlaid feature collection. Default is "k" (black). Examples: .. code-block:: python @@ -1414,7 +1416,6 @@ def plot( # and normalized them if len(bands) == 1: ax.imshow(bands_da[0], extent=[min_x, max_x, min_y, max_y], cmap=cmap) - print(bands_da[0].shape) else: da = np.dstack(bands_da) rgb_image = (da - np.min(da)) / (np.max(da) - np.min(da)) @@ -1425,4 +1426,4 @@ def plot( if fc is not None: gdf = gpd.GeoDataFrame.from_features(fc.getInfo()["features"]) gdf = gdf.set_crs("EPSG:4326").to_crs(crs) - gdf.boundary.plot(ax=ax) + gdf.boundary.plot(ax=ax, color=color) diff --git a/notebooks/.ipynb_checkpoints/chart-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/chart-checkpoint.ipynb deleted file mode 100644 index 87859979..00000000 --- a/notebooks/.ipynb_checkpoints/chart-checkpoint.ipynb +++ /dev/null @@ -1,236 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# chart module\n", - "\n", - "This module relies on `pygal` library, so the returned charts are instances of `pygal.chart`. See options at \n", - "[pygal site][1]\n", - "\n", - "I made a JavaScript 'equivalent': https://code.earthengine.google.com/b2922b860b85c1120250794fb82dfda8\n", - "\n", - " [1]: http://www.pygal.org/en/latest/documentation/index.html" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import ee" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from geetools import ui" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "test_site = ee.Geometry.Point([-71, -42])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "test_feat = ee.Feature(test_site, {'name': 'test feature'})" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "test_featcol = ee.FeatureCollection([\n", - " test_feat, \n", - " test_feat.buffer(100).set('name', 'buffer 100'),\n", - " test_feat.buffer(1000).set('name', 'buffer 1000')\n", - "])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Time Series" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "years = ee.List([2015, 2016, 2017, 2018])" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "col = ee.ImageCollection('COPERNICUS/S2').filterBounds(test_site)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def make_time_series(year):\n", - " ''' make a time series from year's list '''\n", - " eefilter = ee.Filter.calendarRange(year, field='year')\n", - " filtered = col.filter(eefilter)\n", - " return filtered.mean().set('system:time_start', ee.Date.fromYMD(year, 1, 1).millis())" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "time_series = ee.ImageCollection(years.map(make_time_series))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Chart *series*" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "chart_ts = ui.chart.Image.series(**{\n", - " 'imageCollection': time_series, \n", - " 'region': test_site,\n", - " 'scale': 10,\n", - " 'bands': ['B1', 'B2', 'B3'],\n", - " # 'xProperty': 'B4', # You can use a band too!\n", - " 'labels': ['band B1', 'B2 band', 'this is B3']\n", - "})" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7a81b34e7c324831a3b8db3320387803", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=u'\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
linear_functiongaussnormal_distribution
-0.2647060.1932770.0056910.499408
-0.0888900.4444420.0885830.567368
-0.0785140.4592660.1006730.570398
-0.0035320.5663830.2286790.588462
-0.0009020.5701400.2345800.588968
............
0.7979620.2886260.0185350.368387
0.8007280.2846740.0177170.366860
0.8373810.2323130.0094580.346635
0.8640230.1942530.0057670.331999
0.8790070.1728470.0042900.323809
\n", - "

97 rows × 3 columns

\n", - "" - ], - "text/plain": [ - " linear_function gauss normal_distribution\n", - "-0.264706 0.193277 0.005691 0.499408\n", - "-0.088890 0.444442 0.088583 0.567368\n", - "-0.078514 0.459266 0.100673 0.570398\n", - "-0.003532 0.566383 0.228679 0.588462\n", - "-0.000902 0.570140 0.234580 0.588968\n", - "... ... ... ...\n", - " 0.797962 0.288626 0.018535 0.368387\n", - " 0.800728 0.284674 0.017717 0.366860\n", - " 0.837381 0.232313 0.009458 0.346635\n", - " 0.864023 0.194253 0.005767 0.331999\n", - " 0.879007 0.172847 0.004290 0.323809\n", - "\n", - "[97 rows x 3 columns]" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "charts.dataframe" ] diff --git a/notebooks/image/parametrize.ipynb b/notebooks/image/parametrize.ipynb index d1d2e322..ef3f1f05 100644 --- a/notebooks/image/parametrize.ipynb +++ b/notebooks/image/parametrize.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -56,45 +56,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4a4fcb2e36c14b71ba9304fced4b4791", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "62d80240ee174c809b53fa1399aff64a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Tab(children=(CustomInspector(children=(SelectMultiple(options=OrderedDict(), value=()), Accordion(selected_in…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Map.show()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -110,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -135,20 +106,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'B1': 4712}" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tools.image.getValue(i, i.geometry().centroid(), 10, 'client')" ] @@ -162,20 +122,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'B1': 0.4712}" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tools.image.getValue(parametrized, i.geometry().centroid(), 10, 'client')" ] @@ -189,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -207,20 +156,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'B1': 0.5287999999999999}" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tools.image.getValue(switch_parametrized, i.geometry().centroid(), 10, 'client')" ] diff --git a/notebooks/image/removeBands.ipynb b/notebooks/image/removeBands.ipynb index 52b9c884..7e2c1268 100644 --- a/notebooks/image/removeBands.ipynb +++ b/notebooks/image/removeBands.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -39,24 +39,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2eb4faea0a494229bf0d825c9cd96929", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(i.bandNames())" ] @@ -70,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -79,24 +64,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2ffd0ef6ce544319a75ec0fe7bc477f4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(removed.bandNames())" ] @@ -110,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -133,28 +103,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n" - ] - } - ], + "outputs": [], "source": [ "print_bands(col)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -163,21 +121,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['B3', 'B4', 'B5', 'B6', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B3', 'B4', 'B5', 'B6', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B3', 'B4', 'B5', 'B6', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B3', 'B4', 'B5', 'B6', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B3', 'B4', 'B5', 'B6', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n" - ] - } - ], + "outputs": [], "source": [ "print_bands(removed_col)" ] diff --git a/notebooks/image/renameDict.ipynb b/notebooks/image/renameDict.ipynb index 8bf687c4..b13e7c87 100644 --- a/notebooks/image/renameDict.ipynb +++ b/notebooks/image/renameDict.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -55,31 +55,16 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a74ad424f289459a9f4d372447a02ec4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ui.eprint(bands)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -88,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -97,24 +82,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e62f7ef81e1043309a3b2087dd96302c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ui.eprint(renamed_bands)" ] @@ -128,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -137,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -151,28 +121,16 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print_bands(col)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -181,21 +139,9 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['B1', 'BLUE', 'GREEN', 'RED', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'BLUE', 'GREEN', 'RED', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'BLUE', 'GREEN', 'RED', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'BLUE', 'GREEN', 'RED', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n", - "['B1', 'BLUE', 'GREEN', 'RED', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10', 'B11', 'B12', 'QA10', 'QA20', 'QA60']\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print_bands(renamed_col)" ] diff --git a/notebooks/image/renamePattern.ipynb b/notebooks/image/renamePattern.ipynb index 5b5711ac..59f7f46a 100644 --- a/notebooks/image/renamePattern.ipynb +++ b/notebooks/image/renamePattern.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -39,31 +39,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "65b82203da944225bc5e902b712211ae", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(test_i.bandNames())" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -81,31 +66,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bdea2deda21f43e5b3e87eecead2a806", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(renamed.bandNames())" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -114,31 +84,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5f1f7261c9044563a7437232ad4e16e6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(renamed2.bandNames())" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -147,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -156,31 +111,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "08b979ab506e46ada64f624f35b02e66", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(renamed3.bandNames())" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -198,24 +138,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8d86b4e562b640298eb94b4553ac6342", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(renamed4.bandNames())" ] diff --git a/notebooks/image/toGrid.ipynb b/notebooks/image/toGrid.ipynb index e12e1f9d..b9a5c336 100644 --- a/notebooks/image/toGrid.ipynb +++ b/notebooks/image/toGrid.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -102,45 +102,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "44076d6f0d3448dcbaa334606ecc0e39", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4b8355a1e42145808fca87017e6911e7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Tab(children=(CustomInspector(children=(SelectMultiple(options=OrderedDict(), value=()), Accordion(selected_in…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Map.show()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -149,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -158,55 +129,25 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "697c96b3c5044e2fb057d196c373f550", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "eprint(ee.Feature(grid.first()).geometry().projection())" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cc87ac9deb894060a41047f3feeb3ae4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "eprint(i.select(0).projection())" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -215,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -224,24 +165,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "86659a916ba54a5da88bcbdfe9cf795c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "eprint(Map.getObject('reprojected'))" ] diff --git a/notebooks/imagecollection/distributions.ipynb b/notebooks/imagecollection/distributions.ipynb index 37585da1..1fff0e07 100644 --- a/notebooks/imagecollection/distributions.ipynb +++ b/notebooks/imagecollection/distributions.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -99,52 +99,16 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function linearFunctionBand in module geetools.tools.imagecollection:\n", - "\n", - "linearFunctionBand(collection, band, range_min=None, range_max=None, mean=None, output_min=None, output_max=None, name='linear_function')\n", - " Apply a linear function over the bands across every image of the\n", - " ImageCollection using the following formula:\n", - " \n", - " - a = abs(val-mean)\n", - " - b = output_max-output_min\n", - " - c = abs(range_max-mean)\n", - " - d = abs(range_min-mean)\n", - " - e = max(c, d)\n", - " \n", - " f(x) = a*(-1)*(b/e)+output_max\n", - " \n", - " :param band: the band to process\n", - " :param range_min: the minimum pixel value in the parsed band. If None, it\n", - " will be computed reducing the collection\n", - " :param range_max: the maximum pixel value in the parsed band. If None, it\n", - " will be computed reducing the collection\n", - " :param output_min: the minimum value that will take the resulting band.\n", - " :param output_max: the minimum value that will take the resulting band.\n", - " :param mean: the value on the given range that will take the `output_max`\n", - " value\n", - " :param name: the name of the resulting band\n", - " :return: the parsed collection in which every image will have an extra band\n", - " that results of applying the linear function over every pixel in the\n", - " image\n", - " :rtype: ee.ImageCollection\n", - "\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "help(tools.imagecollection.linearFunctionBand)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -153,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -162,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -171,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -180,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -198,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -207,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -216,24 +180,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fa662784dc974130b4fcd60fbea58d8b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value='\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
defaultmean=10mean=10 min=0.5Exponential
-320.0666630.0094180.5000000.500000
-200.3472010.0925350.5419540.503594
-150.5515400.1914950.5919040.510812
-80.8442930.4244930.7095110.539220
-50.9360230.5515400.7736380.562733
01.0000000.7676180.8827040.623294
20.9894770.8442930.9214060.655646
40.9585690.9091850.9541610.692359
60.9091850.9585690.9790870.732741
80.8442930.9894770.9946890.775695
90.8071750.9973590.9986670.797684
100.7676181.0000001.0000000.819730
120.6832960.9894770.9946890.863029
140.5955040.9585690.9790870.903555
160.5081270.9091850.9541610.939209
180.4244930.8442930.9214060.968001
200.3472010.7676180.8827040.988236
230.2468420.6395810.8180771.000000
\n", - "" - ], - "text/plain": [ - " default mean=10 mean=10 min=0.5 Exponential\n", - "-32 0.066663 0.009418 0.500000 0.500000\n", - "-20 0.347201 0.092535 0.541954 0.503594\n", - "-15 0.551540 0.191495 0.591904 0.510812\n", - "-8 0.844293 0.424493 0.709511 0.539220\n", - "-5 0.936023 0.551540 0.773638 0.562733\n", - " 0 1.000000 0.767618 0.882704 0.623294\n", - " 2 0.989477 0.844293 0.921406 0.655646\n", - " 4 0.958569 0.909185 0.954161 0.692359\n", - " 6 0.909185 0.958569 0.979087 0.732741\n", - " 8 0.844293 0.989477 0.994689 0.775695\n", - " 9 0.807175 0.997359 0.998667 0.797684\n", - " 10 0.767618 1.000000 1.000000 0.819730\n", - " 12 0.683296 0.989477 0.994689 0.863029\n", - " 14 0.595504 0.958569 0.979087 0.903555\n", - " 16 0.508127 0.909185 0.954161 0.939209\n", - " 18 0.424493 0.844293 0.921406 0.968001\n", - " 20 0.347201 0.767618 0.882704 0.988236\n", - " 23 0.246842 0.639581 0.818077 1.000000" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "gauss_band_chart.dataframe" ] @@ -916,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -925,7 +435,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -934,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -943,7 +453,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -952,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -961,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -970,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -979,199 +489,18 @@ }, { "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "de7f7e1a693b47e7b313497f070a483b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value='\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
defaultmean=10mean=10 min=0.5
-320.0666630.0094180.500000
-200.3472010.0925350.541954
-150.5515400.1914950.591904
-80.8442930.4244930.709511
-50.9360230.5515400.773638
01.0000000.7676180.882704
20.9894770.8442930.921406
40.9585690.9091850.954161
60.9091850.9585690.979087
80.8442930.9894770.994689
90.8071750.9973590.998667
100.7676181.0000001.000000
120.6832960.9894770.994689
140.5955040.9585690.979087
160.5081270.9091850.954161
180.4244930.8442930.921406
200.3472010.7676180.882704
230.2468420.6395810.818077
\n", - "" - ], - "text/plain": [ - " default mean=10 mean=10 min=0.5\n", - "-32 0.066663 0.009418 0.500000\n", - "-20 0.347201 0.092535 0.541954\n", - "-15 0.551540 0.191495 0.591904\n", - "-8 0.844293 0.424493 0.709511\n", - "-5 0.936023 0.551540 0.773638\n", - " 0 1.000000 0.767618 0.882704\n", - " 2 0.989477 0.844293 0.921406\n", - " 4 0.958569 0.909185 0.954161\n", - " 6 0.909185 0.958569 0.979087\n", - " 8 0.844293 0.989477 0.994689\n", - " 9 0.807175 0.997359 0.998667\n", - " 10 0.767618 1.000000 1.000000\n", - " 12 0.683296 0.989477 0.994689\n", - " 14 0.595504 0.958569 0.979087\n", - " 16 0.508127 0.909185 0.954161\n", - " 18 0.424493 0.844293 0.921406\n", - " 20 0.347201 0.767618 0.882704\n", - " 23 0.246842 0.639581 0.818077" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "gauss_prop.dataframe" ] @@ -1192,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1201,7 +530,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1210,161 +539,18 @@ }, { "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e7510d0fef7242ef8a04edeb7a177fb2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value='\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
default
-320.001287
-200.007266
-150.012136
-80.020259
-50.023448
00.027123
20.027780
40.027901
60.027479
80.026538
90.025889
100.025133
120.023339
140.021253
160.018978
180.016618
200.014269
230.010943
\n", - "" - ], - "text/plain": [ - " default\n", - "-32 0.001287\n", - "-20 0.007266\n", - "-15 0.012136\n", - "-8 0.020259\n", - "-5 0.023448\n", - " 0 0.027123\n", - " 2 0.027780\n", - " 4 0.027901\n", - " 6 0.027479\n", - " 8 0.026538\n", - " 9 0.025889\n", - " 10 0.025133\n", - " 12 0.023339\n", - " 14 0.021253\n", - " 16 0.018978\n", - " 18 0.016618\n", - " 20 0.014269\n", - " 23 0.010943" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "normal_prop_chart.dataframe" ] @@ -1378,7 +564,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1387,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1396,161 +582,18 @@ }, { "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "27290599ce564a86882052b318797197", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value='\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
default
-320.001287
-200.007266
-150.012136
-80.020259
-50.023448
00.027123
20.027780
40.027901
60.027479
80.026538
90.025889
100.025133
120.023339
140.021253
160.018978
180.016618
200.014269
230.010943
\n", - "" - ], - "text/plain": [ - " default\n", - "-32 0.001287\n", - "-20 0.007266\n", - "-15 0.012136\n", - "-8 0.020259\n", - "-5 0.023448\n", - " 0 0.027123\n", - " 2 0.027780\n", - " 4 0.027901\n", - " 6 0.027479\n", - " 8 0.026538\n", - " 9 0.025889\n", - " 10 0.025133\n", - " 12 0.023339\n", - " 14 0.021253\n", - " 16 0.018978\n", - " 18 0.016618\n", - " 20 0.014269\n", - " 23 0.010943" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "normal_band_chart.dataframe" ] diff --git a/notebooks/imagecollection/mosaicSameDay.ipynb b/notebooks/imagecollection/mosaicSameDay.ipynb index e327681c..3fdb9282 100644 --- a/notebooks/imagecollection/mosaicSameDay.ipynb +++ b/notebooks/imagecollection/mosaicSameDay.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -50,38 +50,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3a2da64b8c72434abeef4e1afff3388d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e26b3adfd3e54af18e60b8d07c92533e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Tab(children=(CustomInspector(children=(SelectMultiple(options=OrderedDict(), value=()), Accordion(selected_in…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Map = ui.Map()\n", "Map.show()" @@ -89,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -98,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -125,48 +96,18 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "82140caf91584f758b877eaf0b9c5f8e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(col.size())" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d428d9a800524fe6b53848ebb8e11f4b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Get dates\n", "def get_dates(col):\n", @@ -178,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -187,55 +128,25 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0afcf5ad51ea46518f0675be1f4ec1fa", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(mosaics.size())" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6832d1e18cab4215bb1a61d49c5a5f0d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(get_dates(mosaics))" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -244,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -253,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ diff --git a/notebooks/imagecollection/parametrizeProperty.ipynb b/notebooks/imagecollection/parametrizeProperty.ipynb index 775118a4..c0da2e28 100644 --- a/notebooks/imagecollection/parametrizeProperty.ipynb +++ b/notebooks/imagecollection/parametrizeProperty.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -74,24 +74,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6b157c4a59af4add9821f051383170ce", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(cloud_cover)" ] @@ -105,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,24 +108,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "00814c1b15194170b6354a716c0c2e21", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(Accordion(children=(Button(description='Cancel', style=ButtonStyle()),), _titles={'0': 'Loading…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ui.eprint(out_of_range)" ] diff --git a/notebooks/visualization/stretching.ipynb b/notebooks/visualization/stretching.ipynb deleted file mode 100644 index 5fdf507e..00000000 --- a/notebooks/visualization/stretching.ipynb +++ /dev/null @@ -1,170 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import ee\n", - "ee.Initialize()\n", - "import geetools" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import ipygee as ui" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2f5cf347fe6e41c090181568ebd023d0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "487249a78a8d4d439846e046e63aa9c6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Tab(children=(CustomInspector(children=(SelectMultiple(options=OrderedDict(), value=()), Accordion(selected_in…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Map = ui.Map()\n", - "Map.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Site" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "site = ee.Geometry.Point([-71.5, -41.7]).buffer(2000)\n", - "Map.centerObject(site)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Image" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "image = ee.Image('COPERNICUS/S2/20151123T142942_20170221T180430_T18GYU')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualization\n", - "\n", - "For larger areas you can choose a greater scale to avoid waiting too long for getting visualization values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Standard Deviation" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "for std in range(1, 5):\n", - " stretch = geetools.visualization.stretch_std(image, site, ['B4', 'B3', 'B2'], std, scale=10)\n", - " Map.addLayer(image, stretch, 'RGB stretched by {} standard deviation'.format(std))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Percentile" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# Try many\n", - "for st in range(10, 110, 10):\n", - " stretch = geetools.visualization.stretch_percentile(image, site, ['B4', 'B3', 'B2'], st, scale=10)\n", - " Map.addLayer(image, stretch, 'RGB stretched by {}%'.format(st))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/pyproject.toml b/pyproject.toml index bd1ef084..91d111fb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -76,7 +76,9 @@ doc = [ "ipykernel", "httplib2", "jupyter-sphinx", - "nbsphinx", + "myst-nb", + "pytest-gee", + "sphinx-icon", ] [tool.hatch.build.targets.wheel] diff --git a/tests/test_Image/test_plot_with_fc.png b/tests/test_Image/test_plot_with_fc.png index 1480d17b..5a0dda07 100644 Binary files a/tests/test_Image/test_plot_with_fc.png and b/tests/test_Image/test_plot_with_fc.png differ