diff --git a/README.MD b/README.MD index a9ed3539..6fd6f22d 100644 --- a/README.MD +++ b/README.MD @@ -38,6 +38,8 @@ Or for bleeding edge updates install from the repository: # Using GVAL +### Categorical Example + An example of running the entire process for two-class categorical rasters with one function using minimal arguments is demonstrated below: @@ -55,7 +57,7 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an negative_categories=[0, 1]) ``` -### Outputs +#### Categorical Outputs `agreement_map` @@ -69,8 +71,112 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an ![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/metric_table.png) -For more details on how to use this software, check out this [notebook -tutorial](https://github.com/NOAA-OWP/gval/blob/main/notebooks/Tutorial.ipynb). +### Continuous Example + +The same can be done for rasters with continuous valued statistical data +types as shown below (in this case only a subset of the default +statistics will be run): + +``` python +import gval +import rioxarray as rxr + +candidate = rxr.open_rasterio('livneh_2011_precip.tif', mask_and_scale=True) # VIC +benchmark = rxr.open_rasterio('prism_2011_precip.tif', mask_and_scale=True) # PRISM + +agreement, metric_table = candidate.gval.continuous_compare( + benchmark, + metrics=[ + "coefficient_of_determination", + "mean_percentage_error", + "mean_absolute_percentage_error", + "mean_normalized_mean_absolute_error" + ] +) +``` + +#### Continuous Outputs + +`agreement_map` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/continuous_agreement_map.png) + +`metric_table` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/continuous_metric_table.png) + +### Catalog Example + +Entire catalogs can be compared in GVAL, which are represented by +dataframes of maps. The following is a candidate and benchmark catalog +for continuous datasets: + +`candidate_catalog` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/candidate_catalog.png) + +`benchmark_catalog` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/benchmark_catalog.png) + +With the following code a comparison of each pair of maps can be run +with the following code. Since the parameter `agreement_map_field` is +provided the column `agreement_maps` found in the candidate catalog will +be used to export the agreement map to that location. (Note the first +pair of candidate and benchmark maps are single band rasters while the +second pair are multiband rasters): + +``` python +import pandas as pd + +from gval.catalogs.catalogs import catalog_compare + +candidate_continuous_catalog = pd.read_csv('candidate_catalog_0.csv') +benchmark_continuous_catalog = pd.read_csv('benchmark_catalog_0.csv') + +arguments = { + "candidate_catalog": candidate_continuous_catalog, + "benchmark_catalog": benchmark_continuous_catalog, + "on": "compare_id", + "agreement_map_field": "agreement_maps", + "map_ids": "map_id", + "how": "inner", + "compare_type": "continuous", + "compare_kwargs": { + "metrics": ( + "coefficient_of_determination", + "mean_absolute_error", + "mean_absolute_percentage_error", + ), + "encode_nodata": True, + "nodata": -9999, + }, + "open_kwargs": { + "mask_and_scale": True, + "masked": True + } +} + +agreement_continuous_catalog = catalog_compare(**arguments) +``` + +#### Catalog Outputs + +`agreement_map` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_agreement_map.png) ![alt +text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_agreement_map2.png) + +`catalog_metrics` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_metric_table.png) + +(Note that both catalog level attributes in the candidate and benchmark +catalogs are present in the catalog metrics table.) + +For more detailed examples of how to use this software, check out these +[notebook +tutorials](https://github.com/NOAA-OWP/gval/blob/main/notebooks). # Contributing diff --git a/docs/compile_readme_and_arrange_docs.py b/docs/compile_readme_and_arrange_docs.py index e0978e45..51f250e6 100755 --- a/docs/compile_readme_and_arrange_docs.py +++ b/docs/compile_readme_and_arrange_docs.py @@ -115,6 +115,62 @@ def compile_readme() -> None: 'width="700" height="180" />', ) + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "continuous_agreement_map.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "continuous_metric_table.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "candidate_catalog.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "benchmark_catalog.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "catalog_agreement_map.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "catalog_agreement_map2.png)", + '', + ) + + sphinx_contents = sphinx_contents.replace( + "![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/" + "catalog_metric_table.png)", + '', + ) + sphinx_contents = sphinx_contents.replace( "\nSee the full documentation [here](noaa-owp.github.io/gval/).\n", "" ) diff --git a/docs/images/benchmark_catalog.png b/docs/images/benchmark_catalog.png new file mode 100644 index 00000000..1b6f6a6b Binary files /dev/null and b/docs/images/benchmark_catalog.png differ diff --git a/docs/images/candidate_catalog.png b/docs/images/candidate_catalog.png new file mode 100644 index 00000000..1d8771c0 Binary files /dev/null and b/docs/images/candidate_catalog.png differ diff --git a/docs/images/catalog_agreement_map.png b/docs/images/catalog_agreement_map.png new file mode 100644 index 00000000..dd97376a Binary files /dev/null and b/docs/images/catalog_agreement_map.png differ diff --git a/docs/images/catalog_agreement_map2.png b/docs/images/catalog_agreement_map2.png new file mode 100644 index 00000000..4099e632 Binary files /dev/null and b/docs/images/catalog_agreement_map2.png differ diff --git a/docs/images/catalog_metric_table.png b/docs/images/catalog_metric_table.png new file mode 100644 index 00000000..c0c64298 Binary files /dev/null and b/docs/images/catalog_metric_table.png differ diff --git a/docs/images/continuous_agreement_map.png b/docs/images/continuous_agreement_map.png new file mode 100644 index 00000000..283f8f13 Binary files /dev/null and b/docs/images/continuous_agreement_map.png differ diff --git a/docs/images/continuous_metric_table.png b/docs/images/continuous_metric_table.png new file mode 100644 index 00000000..5bcab139 Binary files /dev/null and b/docs/images/continuous_metric_table.png differ diff --git a/docs/markdown/04_EXAMPLE.MD b/docs/markdown/04_EXAMPLE.MD index f7d2c4d2..4f223025 100644 --- a/docs/markdown/04_EXAMPLE.MD +++ b/docs/markdown/04_EXAMPLE.MD @@ -1,5 +1,6 @@ # Using GVAL +### Categorical Example An example of running the entire process for two-class categorical rasters with one function using minimal arguments is demonstrated below: ```python @@ -16,7 +17,7 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an negative_categories=[0, 1]) ``` -### Outputs +#### Categorical Outputs `agreement_map` @@ -30,5 +31,104 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an ![alt text](../images/metric_table.png) -For more details on how to use this software, check out this -[notebook tutorial](https://github.com/NOAA-OWP/gval/blob/main/notebooks/Tutorial.ipynb). +### Continuous Example + +The same can be done for rasters with continuous valued statistical data types as shown below (in this case only a +subset of the default statistics will be run): + +```python +import gval +import rioxarray as rxr + +candidate = rxr.open_rasterio('livneh_2011_precip.tif', mask_and_scale=True) # VIC +benchmark = rxr.open_rasterio('prism_2011_precip.tif', mask_and_scale=True) # PRISM + +agreement, metric_table = candidate.gval.continuous_compare( + benchmark, + metrics=[ + "coefficient_of_determination", + "mean_percentage_error", + "mean_absolute_percentage_error", + "mean_normalized_mean_absolute_error" + ] +) +``` + +#### Continuous Outputs + +`agreement_map` + +![alt text](../images/continuous_agreement_map.png) + +`metric_table` + +![alt text](../images/continuous_metric_table.png) + +### Catalog Example + +Entire catalogs can be compared in GVAL, which are represented by dataframes of maps. The following is a candidate +and benchmark catalog for continuous datasets: + +`candidate_catalog` + +![alt text](../images/candidate_catalog.png) + +`benchmark_catalog` + +![alt text](../images/benchmark_catalog.png) + +With the following code a comparison of each pair of maps can be run with the following code. Since the parameter +`agreement_map_field` is provided the column `agreement_maps` found in the candidate catalog will be used to +export the agreement map to that location. (Note the first pair of +candidate and benchmark maps are single band rasters while the second pair are multiband rasters): + +```python +import pandas as pd + +from gval.catalogs.catalogs import catalog_compare + +candidate_continuous_catalog = pd.read_csv('candidate_catalog_0.csv') +benchmark_continuous_catalog = pd.read_csv('benchmark_catalog_0.csv') + +arguments = { + "candidate_catalog": candidate_continuous_catalog, + "benchmark_catalog": benchmark_continuous_catalog, + "on": "compare_id", + "agreement_map_field": "agreement_maps", + "map_ids": "map_id", + "how": "inner", + "compare_type": "continuous", + "compare_kwargs": { + "metrics": ( + "coefficient_of_determination", + "mean_absolute_error", + "mean_absolute_percentage_error", + ), + "encode_nodata": True, + "nodata": -9999, + }, + "open_kwargs": { + "mask_and_scale": True, + "masked": True + } +} + +agreement_continuous_catalog = catalog_compare(**arguments) +``` + +#### Catalog Outputs + +`agreement_map` + +![alt text](../images/catalog_agreement_map.png) +![alt text](../images/catalog_agreement_map2.png) + +`catalog_metrics` + +![alt text](../images/catalog_metric_table.png) + +(Note that both catalog level attributes in the candidate and benchmark catalogs are present in the catalog metrics +table.) + +For more detailed examples of how to use this software, check out these +[notebook tutorials](https://github.com/NOAA-OWP/gval/blob/main/notebooks). diff --git a/docs/sphinx/PYPI_README.MD b/docs/sphinx/PYPI_README.MD index 0f1c2fef..ec95105e 100644 --- a/docs/sphinx/PYPI_README.MD +++ b/docs/sphinx/PYPI_README.MD @@ -38,6 +38,8 @@ Or for bleeding edge updates install from the repository: # Using GVAL +### Categorical Example + An example of running the entire process for two-class categorical rasters with one function using minimal arguments is demonstrated below: @@ -55,7 +57,7 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an negative_categories=[0, 1]) ``` -### Outputs +#### Categorical Outputs `agreement_map` @@ -69,8 +71,112 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an ![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/metric_table.png) -For more details on how to use this software, check out this [notebook -tutorial](https://github.com/NOAA-OWP/gval/blob/main/notebooks/Tutorial.ipynb). +### Continuous Example + +The same can be done for rasters with continuous valued statistical data +types as shown below (in this case only a subset of the default +statistics will be run): + +``` python +import gval +import rioxarray as rxr + +candidate = rxr.open_rasterio('livneh_2011_precip.tif', mask_and_scale=True) # VIC +benchmark = rxr.open_rasterio('prism_2011_precip.tif', mask_and_scale=True) # PRISM + +agreement, metric_table = candidate.gval.continuous_compare( + benchmark, + metrics=[ + "coefficient_of_determination", + "mean_percentage_error", + "mean_absolute_percentage_error", + "mean_normalized_mean_absolute_error" + ] +) +``` + +#### Continuous Outputs + +`agreement_map` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/continuous_agreement_map.png) + +`metric_table` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/continuous_metric_table.png) + +### Catalog Example + +Entire catalogs can be compared in GVAL, which are represented by +dataframes of maps. The following is a candidate and benchmark catalog +for continuous datasets: + +`candidate_catalog` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/candidate_catalog.png) + +`benchmark_catalog` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/benchmark_catalog.png) + +With the following code a comparison of each pair of maps can be run +with the following code. Since the parameter `agreement_map_field` is +provided the column `agreement_maps` found in the candidate catalog will +be used to export the agreement map to that location. (Note the first +pair of candidate and benchmark maps are single band rasters while the +second pair are multiband rasters): + +``` python +import pandas as pd + +from gval.catalogs.catalogs import catalog_compare + +candidate_continuous_catalog = pd.read_csv('candidate_catalog_0.csv') +benchmark_continuous_catalog = pd.read_csv('benchmark_catalog_0.csv') + +arguments = { + "candidate_catalog": candidate_continuous_catalog, + "benchmark_catalog": benchmark_continuous_catalog, + "on": "compare_id", + "agreement_map_field": "agreement_maps", + "map_ids": "map_id", + "how": "inner", + "compare_type": "continuous", + "compare_kwargs": { + "metrics": ( + "coefficient_of_determination", + "mean_absolute_error", + "mean_absolute_percentage_error", + ), + "encode_nodata": True, + "nodata": -9999, + }, + "open_kwargs": { + "mask_and_scale": True, + "masked": True + } +} + +agreement_continuous_catalog = catalog_compare(**arguments) +``` + +#### Catalog Outputs + +`agreement_map` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_agreement_map.png) ![alt +text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_agreement_map2.png) + +`catalog_metrics` + +![alt text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_metric_table.png) + +(Note that both catalog level attributes in the candidate and benchmark +catalogs are present in the catalog metrics table.) + +For more detailed examples of how to use this software, check out these +[notebook +tutorials](https://github.com/NOAA-OWP/gval/blob/main/notebooks). # Contributing diff --git a/docs/sphinx/SPHINX_README.MD b/docs/sphinx/SPHINX_README.MD index 1c1f9b8a..3d4917b1 100644 --- a/docs/sphinx/SPHINX_README.MD +++ b/docs/sphinx/SPHINX_README.MD @@ -38,6 +38,8 @@ Or for bleeding edge updates install from the repository: # Using GVAL +### Categorical Example + An example of running the entire process for two-class categorical rasters with one function using minimal arguments is demonstrated below: @@ -55,7 +57,7 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an negative_categories=[0, 1]) ``` -### Outputs +#### Categorical Outputs `agreement_map` @@ -69,8 +71,112 @@ benchmark = rxr.open_rasterio('benchmark_map_two_class_categorical.tif', mask_an -For more details on how to use this software, check out this [notebook -tutorial](https://github.com/NOAA-OWP/gval/blob/main/notebooks/Tutorial.ipynb). +### Continuous Example + +The same can be done for rasters with continuous valued statistical data +types as shown below (in this case only a subset of the default +statistics will be run): + +``` python +import gval +import rioxarray as rxr + +candidate = rxr.open_rasterio('livneh_2011_precip.tif', mask_and_scale=True) # VIC +benchmark = rxr.open_rasterio('prism_2011_precip.tif', mask_and_scale=True) # PRISM + +agreement, metric_table = candidate.gval.continuous_compare( + benchmark, + metrics=[ + "coefficient_of_determination", + "mean_percentage_error", + "mean_absolute_percentage_error", + "mean_normalized_mean_absolute_error" + ] +) +``` + +#### Continuous Outputs + +`agreement_map` + + + +`metric_table` + + + +### Catalog Example + +Entire catalogs can be compared in GVAL, which are represented by +dataframes of maps. The following is a candidate and benchmark catalog +for continuous datasets: + +`candidate_catalog` + + + +`benchmark_catalog` + + + +With the following code a comparison of each pair of maps can be run +with the following code. Since the parameter `agreement_map_field` is +provided the column `agreement_maps` found in the candidate catalog will +be used to export the agreement map to that location. (Note the first +pair of candidate and benchmark maps are single band rasters while the +second pair are multiband rasters): + +``` python +import pandas as pd + +from gval.catalogs.catalogs import catalog_compare + +candidate_continuous_catalog = pd.read_csv('candidate_catalog_0.csv') +benchmark_continuous_catalog = pd.read_csv('benchmark_catalog_0.csv') + +arguments = { + "candidate_catalog": candidate_continuous_catalog, + "benchmark_catalog": benchmark_continuous_catalog, + "on": "compare_id", + "agreement_map_field": "agreement_maps", + "map_ids": "map_id", + "how": "inner", + "compare_type": "continuous", + "compare_kwargs": { + "metrics": ( + "coefficient_of_determination", + "mean_absolute_error", + "mean_absolute_percentage_error", + ), + "encode_nodata": True, + "nodata": -9999, + }, + "open_kwargs": { + "mask_and_scale": True, + "masked": True + } +} + +agreement_continuous_catalog = catalog_compare(**arguments) +``` + +#### Catalog Outputs + +`agreement_map` + + ![alt +text](https://github.com/NOAA-OWP/gval/raw/main/docs/images/catalog_agreement_map2.png) + +`catalog_metrics` + + + +(Note that both catalog level attributes in the candidate and benchmark +catalogs are present in the catalog metrics table.) + +For more detailed examples of how to use this software, check out these +[notebook +tutorials](https://github.com/NOAA-OWP/gval/blob/main/notebooks). # Contributing diff --git a/docs/sphinx/SphinxCatalogTutorial.ipynb b/docs/sphinx/SphinxCatalogTutorial.ipynb index e192e984..61ab3cba 100644 --- a/docs/sphinx/SphinxCatalogTutorial.ipynb +++ b/docs/sphinx/SphinxCatalogTutorial.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 2, "id": "b66eca6a-007f-42d2-a476-054b70c2395c", "metadata": {}, "outputs": [], @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 3, "id": "972505a1", "metadata": {}, "outputs": [ @@ -98,6 +98,7 @@ " map_id\n", " compare_id\n", " agreement_maps\n", + " catalog_attribute_1\n", " \n", " \n", " \n", @@ -106,29 +107,36 @@ " ./candidate_categorical_0.tif\n", " compare1\n", " agreement_categorical_0.tif\n", + " 1\n", " \n", " \n", " 1\n", " ./candidate_categorical_1.tif\n", " compare2\n", " agreement_categorical_1.tif\n", + " 2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id agreement_maps\n", - "0 ./candidate_categorical_0.tif compare1 agreement_categorical_0.tif\n", - "1 ./candidate_categorical_1.tif compare2 agreement_categorical_1.tif" + " map_id compare_id agreement_maps \\\n", + "0 ./candidate_categorical_0.tif compare1 agreement_categorical_0.tif \n", + "1 ./candidate_categorical_1.tif compare2 agreement_categorical_1.tif \n", + "\n", + " catalog_attribute_1 \n", + "0 1 \n", + "1 2 " ] }, - "execution_count": 73, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "candidate_categorical_catalog['catalog_attribute_1'] = [1, 2]\n", "candidate_categorical_catalog" ] }, @@ -153,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 4, "id": "f09a9c91-8bc4-41bc-b11a-733412ba091d", "metadata": {}, "outputs": [ @@ -180,6 +188,7 @@ " \n", " map_id\n", " compare_id\n", + " catalog_attribute_2\n", " \n", " \n", " \n", @@ -187,28 +196,31 @@ " 0\n", " ./benchmark_categorical_0.tif\n", " compare1\n", + " 3\n", " \n", " \n", " 1\n", " ./benchmark_categorical_1.tif\n", " compare2\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id\n", - "0 ./benchmark_categorical_0.tif compare1\n", - "1 ./benchmark_categorical_1.tif compare2" + " map_id compare_id catalog_attribute_2\n", + "0 ./benchmark_categorical_0.tif compare1 3\n", + "1 ./benchmark_categorical_1.tif compare2 4" ] }, - "execution_count": 74, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "benchmark_categorical_catalog['catalog_attribute_2'] = [3, 4]\n", "benchmark_categorical_catalog" ] }, @@ -240,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 5, "id": "d6034a81", "metadata": {}, "outputs": [ @@ -290,12 +302,24 @@ " agreement_categorical_1.tif\n", " \n", " \n", + " catalog_attribute_1\n", + " 1\n", + " 2\n", + " 2\n", + " \n", + " \n", " map_id_benchmark\n", " ./benchmark_categorical_0.tif\n", " ./benchmark_categorical_1.tif\n", " ./benchmark_categorical_1.tif\n", " \n", " \n", + " catalog_attribute_2\n", + " 3\n", + " 4\n", + " 4\n", + " \n", + " \n", " band\n", " 1\n", " 1\n", @@ -352,7 +376,9 @@ "map_id_candidate ./candidate_categorical_0.tif \n", "compare_id compare1 \n", "agreement_maps agreement_categorical_0.tif \n", + "catalog_attribute_1 1 \n", "map_id_benchmark ./benchmark_categorical_0.tif \n", + "catalog_attribute_2 3 \n", "band 1 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -366,7 +392,9 @@ "map_id_candidate ./candidate_categorical_1.tif \n", "compare_id compare2 \n", "agreement_maps agreement_categorical_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_categorical_1.tif \n", + "catalog_attribute_2 4 \n", "band 1 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -380,7 +408,9 @@ "map_id_candidate ./candidate_categorical_1.tif \n", "compare_id compare2 \n", "agreement_maps agreement_categorical_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_categorical_1.tif \n", + "catalog_attribute_2 4 \n", "band 2 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -391,7 +421,7 @@ "positive_predictive_value 0.700815 " ] }, - "execution_count": 112, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -435,13 +465,13 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 6, "id": "18b0df29", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -451,7 +481,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -462,7 +492,9 @@ ], "source": [ "for ag_map in agreement_categorical_catalog['agreement_maps'].unique():\n", - " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cat_plot(title=ag_map)" + " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cat_plot(\n", + " title=f'Agreement Map {int(ag_map.split(\"_\")[-1][0]) + 1}'\n", + " )" ] }, { @@ -483,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 7, "id": "a86f7eca", "metadata": {}, "outputs": [ @@ -511,6 +543,7 @@ " map_id\n", " compare_id\n", " agreement_maps\n", + " catalog_attribute_1\n", " \n", " \n", " \n", @@ -519,35 +552,42 @@ " ./candidate_continuous_0.tif\n", " compare1\n", " ./agreement_continuous_0.tif\n", + " 1\n", " \n", " \n", " 1\n", " ./candidate_continuous_1.tif\n", " compare2\n", " ./agreement_continuous_1.tif\n", + " 2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id agreement_maps\n", - "0 ./candidate_continuous_0.tif compare1 ./agreement_continuous_0.tif\n", - "1 ./candidate_continuous_1.tif compare2 ./agreement_continuous_1.tif" + " map_id compare_id agreement_maps \\\n", + "0 ./candidate_continuous_0.tif compare1 ./agreement_continuous_0.tif \n", + "1 ./candidate_continuous_1.tif compare2 ./agreement_continuous_1.tif \n", + "\n", + " catalog_attribute_1 \n", + "0 1 \n", + "1 2 " ] }, - "execution_count": 90, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "candidate_continuous_catalog['catalog_attribute_1'] = [1, 2]\n", "candidate_continuous_catalog" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 8, "id": "1b94b2cc", "metadata": {}, "outputs": [ @@ -574,6 +614,7 @@ " \n", " map_id\n", " compare_id\n", + " catalog_attribute_2\n", " \n", " \n", " \n", @@ -581,28 +622,31 @@ " 0\n", " ./benchmark_continuous_0.tif\n", " compare1\n", + " 3\n", " \n", " \n", " 1\n", " ./benchmark_continuous_1.tif\n", " compare2\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id\n", - "0 ./benchmark_continuous_0.tif compare1\n", - "1 ./benchmark_continuous_1.tif compare2" + " map_id compare_id catalog_attribute_2\n", + "0 ./benchmark_continuous_0.tif compare1 3\n", + "1 ./benchmark_continuous_1.tif compare2 4" ] }, - "execution_count": 91, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "benchmark_continuous_catalog['catalog_attribute_2'] = [3, 4]\n", "benchmark_continuous_catalog" ] }, @@ -616,7 +660,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 9, "id": "6dad7a6d", "metadata": {}, "outputs": [ @@ -643,6 +687,7 @@ " \n", " 0\n", " 1\n", + " 2\n", " \n", " \n", " \n", @@ -650,41 +695,61 @@ " map_id_candidate\n", " ./candidate_continuous_0.tif\n", " ./candidate_continuous_1.tif\n", + " ./candidate_continuous_1.tif\n", " \n", " \n", " compare_id\n", " compare1\n", " compare2\n", + " compare2\n", " \n", " \n", " agreement_maps\n", " ./agreement_continuous_0.tif\n", " ./agreement_continuous_1.tif\n", + " ./agreement_continuous_1.tif\n", + " \n", + " \n", + " catalog_attribute_1\n", + " 1\n", + " 2\n", + " 2\n", " \n", " \n", " map_id_benchmark\n", " ./benchmark_continuous_0.tif\n", " ./benchmark_continuous_1.tif\n", + " ./benchmark_continuous_1.tif\n", + " \n", + " \n", + " catalog_attribute_2\n", + " 3\n", + " 4\n", + " 4\n", " \n", " \n", " band\n", " 1\n", " 1\n", + " 2\n", " \n", " \n", " coefficient_of_determination\n", " -0.06616\n", - " -0.329965\n", + " -2.829421\n", + " 0.10903\n", " \n", " \n", " mean_absolute_error\n", " 0.317389\n", " 0.485031\n", + " 0.485031\n", " \n", " \n", " mean_absolute_percentage_error\n", " 0.159568\n", - " 0.177735\n", + " 0.202235\n", + " 0.153235\n", " \n", " \n", "\n", @@ -695,24 +760,40 @@ "map_id_candidate ./candidate_continuous_0.tif \n", "compare_id compare1 \n", "agreement_maps ./agreement_continuous_0.tif \n", + "catalog_attribute_1 1 \n", "map_id_benchmark ./benchmark_continuous_0.tif \n", + "catalog_attribute_2 3 \n", "band 1 \n", "coefficient_of_determination -0.06616 \n", "mean_absolute_error 0.317389 \n", "mean_absolute_percentage_error 0.159568 \n", "\n", - " 1 \n", + " 1 \\\n", + "map_id_candidate ./candidate_continuous_1.tif \n", + "compare_id compare2 \n", + "agreement_maps ./agreement_continuous_1.tif \n", + "catalog_attribute_1 2 \n", + "map_id_benchmark ./benchmark_continuous_1.tif \n", + "catalog_attribute_2 4 \n", + "band 1 \n", + "coefficient_of_determination -2.829421 \n", + "mean_absolute_error 0.485031 \n", + "mean_absolute_percentage_error 0.202235 \n", + "\n", + " 2 \n", "map_id_candidate ./candidate_continuous_1.tif \n", "compare_id compare2 \n", "agreement_maps ./agreement_continuous_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_continuous_1.tif \n", - "band 1 \n", - "coefficient_of_determination -0.329965 \n", + "catalog_attribute_2 4 \n", + "band 2 \n", + "coefficient_of_determination 0.10903 \n", "mean_absolute_error 0.485031 \n", - "mean_absolute_percentage_error 0.177735 " + "mean_absolute_percentage_error 0.153235 " ] }, - "execution_count": 101, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -754,13 +835,13 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 10, "id": "c97ea173", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -770,7 +851,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -781,7 +862,9 @@ ], "source": [ "for ag_map in agreement_continuous_catalog['agreement_maps'].unique():\n", - " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cont_plot(title=ag_map)" + " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cont_plot(\n", + " title=f'Agreement Map {int(ag_map.split(\"_\")[-1][0]) + 1}'\n", + " )" ] } ], diff --git a/docs/sphinx/SphinxSubsamplingTutorial.ipynb b/docs/sphinx/SphinxSubsamplingTutorial.ipynb index 96cab560..b66a18d1 100644 --- a/docs/sphinx/SphinxSubsamplingTutorial.ipynb +++ b/docs/sphinx/SphinxSubsamplingTutorial.ipynb @@ -1790,9 +1790,7 @@ "cell_type": "code", "execution_count": 25, "id": "a9e533c6", - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "data": { diff --git a/docs/sphinx/index.rst b/docs/sphinx/index.rst index 9010a5b1..07a7d1c2 100644 --- a/docs/sphinx/index.rst +++ b/docs/sphinx/index.rst @@ -16,11 +16,7 @@ ___________________________________ :maxdepth: 3 :caption: Table of Contents - SphinxTutorial - SphinxMulticatTutorial - SphinxContinuousTutorial - SphinxSubsamplingTutorial - SphinxCatalogTutorial + tutorials api contributing diff --git a/docs/sphinx/tutorials.rst b/docs/sphinx/tutorials.rst index 847a6575..f3a71d09 100644 --- a/docs/sphinx/tutorials.rst +++ b/docs/sphinx/tutorials.rst @@ -8,3 +8,5 @@ Tutorials SphinxTutorial SphinxMulticatTutorial SphinxContinuousTutorial + SphinxSubsamplingTutorial + SphinxCatalogTutorial diff --git a/notebooks/Catalog Tutorial.ipynb b/notebooks/Catalog Tutorial.ipynb index e192e984..61ab3cba 100644 --- a/notebooks/Catalog Tutorial.ipynb +++ b/notebooks/Catalog Tutorial.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 2, "id": "b66eca6a-007f-42d2-a476-054b70c2395c", "metadata": {}, "outputs": [], @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 3, "id": "972505a1", "metadata": {}, "outputs": [ @@ -98,6 +98,7 @@ " map_id\n", " compare_id\n", " agreement_maps\n", + " catalog_attribute_1\n", " \n", " \n", " \n", @@ -106,29 +107,36 @@ " ./candidate_categorical_0.tif\n", " compare1\n", " agreement_categorical_0.tif\n", + " 1\n", " \n", " \n", " 1\n", " ./candidate_categorical_1.tif\n", " compare2\n", " agreement_categorical_1.tif\n", + " 2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id agreement_maps\n", - "0 ./candidate_categorical_0.tif compare1 agreement_categorical_0.tif\n", - "1 ./candidate_categorical_1.tif compare2 agreement_categorical_1.tif" + " map_id compare_id agreement_maps \\\n", + "0 ./candidate_categorical_0.tif compare1 agreement_categorical_0.tif \n", + "1 ./candidate_categorical_1.tif compare2 agreement_categorical_1.tif \n", + "\n", + " catalog_attribute_1 \n", + "0 1 \n", + "1 2 " ] }, - "execution_count": 73, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "candidate_categorical_catalog['catalog_attribute_1'] = [1, 2]\n", "candidate_categorical_catalog" ] }, @@ -153,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 4, "id": "f09a9c91-8bc4-41bc-b11a-733412ba091d", "metadata": {}, "outputs": [ @@ -180,6 +188,7 @@ " \n", " map_id\n", " compare_id\n", + " catalog_attribute_2\n", " \n", " \n", " \n", @@ -187,28 +196,31 @@ " 0\n", " ./benchmark_categorical_0.tif\n", " compare1\n", + " 3\n", " \n", " \n", " 1\n", " ./benchmark_categorical_1.tif\n", " compare2\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id\n", - "0 ./benchmark_categorical_0.tif compare1\n", - "1 ./benchmark_categorical_1.tif compare2" + " map_id compare_id catalog_attribute_2\n", + "0 ./benchmark_categorical_0.tif compare1 3\n", + "1 ./benchmark_categorical_1.tif compare2 4" ] }, - "execution_count": 74, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "benchmark_categorical_catalog['catalog_attribute_2'] = [3, 4]\n", "benchmark_categorical_catalog" ] }, @@ -240,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 5, "id": "d6034a81", "metadata": {}, "outputs": [ @@ -290,12 +302,24 @@ " agreement_categorical_1.tif\n", " \n", " \n", + " catalog_attribute_1\n", + " 1\n", + " 2\n", + " 2\n", + " \n", + " \n", " map_id_benchmark\n", " ./benchmark_categorical_0.tif\n", " ./benchmark_categorical_1.tif\n", " ./benchmark_categorical_1.tif\n", " \n", " \n", + " catalog_attribute_2\n", + " 3\n", + " 4\n", + " 4\n", + " \n", + " \n", " band\n", " 1\n", " 1\n", @@ -352,7 +376,9 @@ "map_id_candidate ./candidate_categorical_0.tif \n", "compare_id compare1 \n", "agreement_maps agreement_categorical_0.tif \n", + "catalog_attribute_1 1 \n", "map_id_benchmark ./benchmark_categorical_0.tif \n", + "catalog_attribute_2 3 \n", "band 1 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -366,7 +392,9 @@ "map_id_candidate ./candidate_categorical_1.tif \n", "compare_id compare2 \n", "agreement_maps agreement_categorical_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_categorical_1.tif \n", + "catalog_attribute_2 4 \n", "band 1 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -380,7 +408,9 @@ "map_id_candidate ./candidate_categorical_1.tif \n", "compare_id compare2 \n", "agreement_maps agreement_categorical_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_categorical_1.tif \n", + "catalog_attribute_2 4 \n", "band 2 \n", "fn 844.0 \n", "fp 844.0 \n", @@ -391,7 +421,7 @@ "positive_predictive_value 0.700815 " ] }, - "execution_count": 112, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -435,13 +465,13 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 6, "id": "18b0df29", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -451,7 +481,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5AAAAF+CAYAAAD0nfX/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACGx0lEQVR4nO3dd3zN1/8H8Ne92XtHhEhixx41IkaMir1XhKJKqZhfJIoarSpV1CgtmqitNjUrtphFqR1iZpDIJuue3x/53StXhpt5701ez8fjPh7yWfecz437zvtzlkQIIUBERERERET0EVJ1F4CIiIiIiIi0AxNIIiIiIiIiUgkTSCIiIiIiIlIJE0giIiIiIiJSCRNIIiIiIiIiUgkTSCIiIiIiIlIJE0giIiIiIiJSCRNIIiIiIiIiUgkTSCIiIiIiIlIJE0gi0nqXLl2CRCKBRCLB3Llz1V0cKkRDhw5VfLZffvlljsclJyfD2tpacezJkyeLr5AqiImJwebNm+Ht7Q1XV1fo6+vDzMwMTZo0wc8//4zU1NR8X7tNmzYoX748kpOTFdtCQ0MV9yK31+zZs5Wu9eF+qVQKS0tLtGjRAmvXroUQIsv7x8XFYc6cOWjQoAHMzMxgYGCA8uXLw93dHZMnT8bp06dzLPuLFy8wffp0NG7cGLa2ttDT04O1tTUaN26MSZMm4dKlS/m+L3IPHjyAkZERJBIJ2rVrl+0xgYGBGDBgANzc3GBtbQ19fX04OjqiT58+OHfuXLbnXL16FbNnz0azZs1gaWkJfX19ODk5YdCgQfj3338/Wq5Tp06hd+/ecHBwgIGBARwdHdGxY0fs27dP6biwsDAYGRnhq6++ynvliYiKgiAi0nK+vr4CgAAgqlatqu7i0AdmzZolAIiAgIA8nztkyBDFZ2tlZSWSk5OzPW7nzp2K4wCIEydOFKzQhWz69OkCgJBIJKJ+/fqif//+ok2bNsLAwEAAEM2bNxeJiYl5vu6BAwcEALFy5Uql7Y8fPxYAhImJiRgyZEiOr927dyudJ79/8v2DBg0S7u7uQiKRCABiwIABSsc/efJEuLi4KN6rTZs2wtvbW3h5eQkbGxsBQHh5eWVb9pUrVyrqb21tLby8vMTAgQNF586dhZOTk6IsX331VZ7vS2aenp6K8rdt2zbbYxo2bCh0dXVF/fr1RdeuXUXfvn1FnTp1FJ/ZqlWrlI5PTU1VlM/a2lp07NhR9OnTR1SqVEkAEPr6+uLPP//MsUzy/xMGBgaiTZs2YsCAAaJFixbCxMREDB8+PMvx48aNE7q6uuLevXsFuhdERIWBCSQRabWUlBRha2srAAgHBwcBQFy4cEHdxaJMCiOBrF+/vgCQJeGR69mzp9DR0RF169bVyATy+++/F1OnThVPnjxR2n7//n1RoUIFAUBMmzYtz9etU6eOsLOzy5JYyxNIZ2fnPF1PnhR96OjRo0JXV1cAEPv371ds79q1qyJJjIqKUjonPT1dHD9+XCxZsiTL9VauXCkACFNTU/H777+LtLS0LMdcunRJdO3aNcekTxVr164VAMTIkSNzTSAvXLgg4uLismzfu3ev0NHREYaGhuLVq1eK7ampqaJRo0Ziz549SmVPT09XPCwwMzNTOkcuICBAABBNmjQRz549U9qXmJgobt68meWc58+fC6lUKvr166dy3YmIigoTSCLSavv27RMAhIeHh5g7d64AIMaMGaPuYlEmhZFALly4UEilUtGnT58sx7x580YYGBiI9u3bCy8vL41MIHOzefNmAUC4uLjk6byzZ88KAMLX1zfLvsJOIIUQYtiwYQKAooUsKSlJkVQ+ePBA5fcIDQ0VBgYGQiqVilOnTn30+CtXrqh87czCw8OFlZWV+PTTT8WJEydyTSBz07ZtWwFA7N27V6XjZTKZqFatmgAgAgMDlfYlJSUJGxsbYWZmJsLCwvJcDj09PREeHp6n84iIChvHQBKRVtu4cSMAYNCgQRg0aBAAYNu2bbmOKfv333/RtWtXWFpawszMDC1btsSxY8dw8uRJSCQSDB06VOl4+Ti8kydP4siRI2jdujUsLS0hkUgQExOjOO7w4cPo3Lkz7OzsYGBggIoVK2LSpEmIiorKthxCCGzZsgVt2rSBlZUVDA0N4ebmhtmzZyMpKSnL8Z6enpBIJAgNDcW2bdvQqFEjGBsbo1y5cpg6dSpSUlIAACEhIfD29oa9vT2MjY3RunXrXMdk5aXcme/F6dOn0aZNG5iZmcHc3BydO3fG7du3lY53cXHBnDlzAADDhg1TGl+Xl3GKZcuWRZs2bXDgwAHExsYq7du+fTuSk5MVn392rl+/jqlTp6Jhw4ZK9fzqq6/w8uXLLMfLxxB6enoiLi4O48ePh5OTk+IzWrJkCWQymcrlz03dunUBINty5Gbt2rUAAG9v70Ipx8fUr18fAPDs2TMAwJs3b5CWlgYAsLOzU/k6y5cvR3JyMgYMGICWLVt+9PiGDRvmo7TA+PHj8fbtW/zyyy/5Ol9OT08PAKCvr6/S8RKJBHXq1AGQ9TPdtWsXoqKi0LdvXzg4OOSpHAMHDkRqaioCAwPzdB4RUWFjAklEWis2Nhb79u2Dvr4++vXrB1dXVzRr1gyvX7/G4cOHsz0nODgY7u7uOHDgAJydndGlSxe8e/cOHTp0wK5du3J9v82bN6Njx45ITExEx44d0ahRI0gkEgCAv78/OnbsiL///hvVqlVDt27doKuriyVLlqBJkyaIiIhQupZMJoOPjw8GDhyIy5cvo169eujUqRMSExMxZ84ctG7dGm/fvs22HD///DMGDRoES0tLdOjQASkpKfjxxx8xYsQIPHjwAE2bNsX169fRpk0bVK5cGSdPnkTr1q2zlCE/5Zbbv38/2rRpg6SkJHTq1Ally5bFwYMH0bJlS4SHhyuO69OnjyJB8vDwwJAhQxSvvP4B7ePjg3fv3mHnzp1K2zdt2gRjY2P07Nkzx3N/+OEHLFmyBADQvHlzdOrUCUIIrFq1Cp988kmOyVtycjLatGmDP/74A40bN8ann36KJ0+eYNKkSfj888/zVP6cPHr0CADyfD/++usvGBkZoXHjxoVSjo+Jj48HABgYGAAAbG1tYWhoCAB5StIOHToEoGCJr/xBxoeTAMkdPHgQ27Ztw9dff43KlSvn+32OHz+OoKAgWFlZoWnTpiqfl9NnGhQUBABo1qwZYmJisHLlSowePRqTJk3Cjh07FAl5djw9PQFkfO5ERGql7iZQIqL8ko9v6t69u2LbL7/8IgCIvn37Zjk+PT1dVK1aVQAQ8+bNy/Za+P8JRDLLPJHL1q1bs1x3+/btAoCoVauWUlc+mUwmvvnmGwFA9O/fX+mchQsXCgDC09NTqStbcnKyGD58uAAg/Pz8lM5p1aqVYtzY5cuXFdvDwsJEmTJlhEQiEW5ubsLf31/IZDJFGQYPHiwAiG+++abA5ZbfC6lUqjQeMS0tTfTu3VsAEDNnzlQ6pzC6sG7YsEHExcUJIyMj0bp1a8X+J0+eCIlEIry9vYUQIscurEFBQVm6/qWnp4s5c+YIAGLYsGFK++RdQAGIOnXqKI1le/jwoXB0dMx1TGZetGvXTgAQY8eOVfmcO3fuCACiWbNm2e4v7C6sMplMuLu7CwBi+vTpiu1ffvml4pxPPvlEzJ49W/z1118iMjIy2+unpKQoJrR5/vx5nsqWmfz3YtasWVn2JSQkCGdnZ1GtWjXF2FBVu7D+/vvvYsiQIaJ///7ik08+EQCEhYWFOHz4sMplO3PmjGIinZcvXyrta9q0qQAg5s+fL8qWLas08RMAUbt2bfH06dMcr21raysMDAzE27dvVS4PEVFhYwJJRFpLnlBlnu3w9evXQk9PTxgaGoqYmBil448dOyYAiCpVqoj09PQs1/Pw8Mg1gezcuXO25ZBP3JLd5BcymUzUq1dP6OjoKJKQ1NRUYWtrK0xMTLIdz5SUlCQcHByElZWVUjnl9Z0xY0aWcyZOnCgAiIoVK4qUlBSlfTdu3BAARKtWrQpU7sz3wsfHJ8s5V65cyfZ9CiuBFEKIfv36CalUqkg+vv/+ewFA/PXXX0KInBPI3JQrV07Y2NgobcucQB49ejTLOatWrcr3mLrsrmNpaSlevHih8nnbtm3LNvGVy1z+3F7Xrl1TOu/DBDItLU3cv39fDB06VDFr6MOHDxX7k5KSxLBhwxRJofwlkUhE48aNszxwCQ8PVxzz7t27LOW+f/9+trPFfjgZjb+/v6hWrZpYvnx5lmtMmDAhy++Aqgmk/OGN/GVtbS127tyZ6zmZxcbGiipVqmT7AEgIoRgbqaurK2rWrCnOnDkj4uLixMWLF0WDBg0EANGoUSPFA6APyb+j/vnnH5XLRERU2HRVb6skItIcT58+xenTp2FpaYmuXbsqttvY2KBTp07Yu3cv/vzzT3zxxReKffL13Hr37g2pNGsP/v79++e45hsAdOvWLcu2yMhI3LhxA1WqVEGtWrWy7JdIJPDw8MD169dx9epVeHl54Z9//sHr16/x6aefokyZMlnOMTIyQsOGDfHXX3/hwYMHqFatmtL+9u3bZzmnYsWKADK6ucnHbH24LywsrEDl/lgZqlatmuV9CtugQYOwfft2bN68GVOmTMGmTZtgb2+fbXk+FBUVhX379uHWrVuIiYlBeno6ACA1NRVRUVGIjo6GtbW10jnW1tb49NNPs1zL29sbo0ePxvnz5yGTybL9ffqYM2fOYPz48ZBIJPj999/h6Oio8rmRkZEAACsrq1yPMzExQZ8+fXLc/2F95eRdszMzMzPD+vXrUalSJcU2IyMj/P777/j666+xc+dOnD17FpcvX0ZERAQuXbqEAQMG4Pz58/j5559VqRYiIiKwfv36LNtnz54NW1tbxc/z58/H/Pnzsxx35coVLFu2DJ999pmiy2derF27FmvXrkVCQgLu3buHhQsXonfv3hgxYgR+++23XM9NT0+Hj48PHjx4gMaNG2e7Jq183KyOjg4OHToEJycnAEDjxo1x6NAhVKxYEZcvX8bff/+d7e+d/PN69epVnutGRFRYmEASkVbatGkThBDo06ePYkyW3KBBg7B3715s3LhRKYGUJzbyP9o+VKFChVzfM7v9oaGhADIWK8/uj+7MXr9+rXTOsWPHVDrnwwSyXLlyWY4zNTX96L4PF5rPa7kzK1++fJZtZmZmWd6nsHXo0AE2NjbYtGkT2rVrh//++w9jx46Frm7u4WzLli0YOXIkEhIScjwmPj4+S0Ll7Oyc7bEWFhawtLRETEwM3rx5AxsbmzzV49atW+jevTtSUlKwbNmyXMdvZkc+kZD8nufE1tY2X5OuDBkyBAAglUphbm6O2rVro1evXjkmrJUrV4afnx/8/PwAAP/88w9mz56N/fv3Y9myZejXrx88PDxgbW0NiUQCIQRev36d5fe1efPmEEIofq5evTru3bunUpnT0tIwYsQIWFpaYtGiRXmuc2ampqZo2LAhtm3bhnfv3mHNmjXw8vJC7969czxn9OjROHDgAKpVq4a//vor20l35P8X27Ztm+V7yN7eHp07d8b27dtx6tSpbBNIc3NzAFCavIuIqLgxgSQirbRhwwYAwMmTJ9G8eXOlffLZSE+fPo0nT57kmATklXzCkMzkLQoODg5ZWuk+JC+H/JzKlSvDw8Mj13OyS0xya+1StSUsP+XOz/sUNj09PfTr1w+rVq3C119/DQC5zr4KAE+ePFHMrLt06VJ07twZ5cqVg5GREYCMCU2Cg4OVEpei9PjxY7Rv3x5v3rzB7NmzMXbs2Dxfw8LCAsD7iW0KW0Fn+mzQoAH27NmDJk2a4MqVK/jrr7/g4eEBPT09uLm54fbt27h27Vq2Dzzy6/nz57h+/TocHBzQt29fpX3yhOvq1auKlklVZwEeNGgQ9u3bh7179+aYQPr7+2PNmjVwcnLCsWPHlFpLM3N2dsa1a9fg4uKS7X75dnkL84fkDw4sLS1VKjsRUVFgAklEWufq1au4c+cOAODhw4d4+PBhtscJIbBp0yZFolG2bFkA75ch+FBO23Mjb4nLS0uP/Jzq1aurbUr+/JRbUwwaNAirVq3C4cOHUbVq1Y/OQnrw4EGkpKRg8uTJGD9+fJb98hkzs/P06dNst8fFxSEmJgZGRkZ5+mM+LCwMn376KcLCwjB+/HjMmjVL5XMzs7e3BwBER0fn6/ziIJVK0apVK1y5ckWpFbtjx464ffs2tm7dii5duhT6+4aHhyvNBJxZTEwMTp06lafryZPBnLqNLly4EAsWLIC9vT2OHTuWYw8HIGMplD179uDNmzfZ7pd/nvKWyg/Jz8vLsilERIWNy3gQkdaRr/04efJkiIzJwLK85K0L8mMBKFr7du/enW1r0/bt2/NclvLly6N69eq4ffs27t+/r9I5jRo1goWFBU6dOqW2BCA/5c4veVe+3JYoyItmzZqhbt26sLGxUWkpDfkf3dl1uz19+nSOS5UAGeMmjx8/nmX71q1bAQDu7u7Q0dFRqdxv3ryBl5cXQkJCMGzYMMWyIvkhXxpF1e6d6iJ/uJO5pXHs2LHQ19fHli1bcPr06UJ7LxcXlxy/D06cOAEgo+uofJuq5Aln5rGfcmvWrIGfnx8sLS1x5MiRLN3NPyQfR33+/Pksa9XKZDKcPXsWwPs1Nz909+5dGBgYwM3NTeXyExEVNiaQRKRV0tPTsWXLFgC5ryPXokULlCtXDnfu3MHVq1cBAG3atEGVKlUUk2NkFhgYiDNnzuSrTDNnzoRMJkPv3r1x/fr1LPujoqKwZs0axc8GBgaYOnUq4uPj0atXr2xbwF68eKHopltU8lru/JJPDlOYyc7169fx+vVrxZi73Mgn99m4cSMSExMV21+8eIFRo0Z99PzJkycjKipK8fPjx48VE6SMGTNGpfImJSWhc+fOuHnzJvr164c1a9Z8dOxpbqpVqwZ7e3tcv3690BLzvIqJiUHjxo2xY8cORbdxOZlMhrVr12Lfvn2QSqVKYzydnZ2xePFiyGQydO7cGQEBAYoJjTK7e/duji1106ZNQ/Xq1bFixYoC1+POnTvYvn17ljoIIbB161YsXLgQEolEMS5UbseOHRg1ahRMTU1x8OBB1KtX76PvVa9ePcVaojNmzFBKZL/77jvcvXsX9vb26NWrV5ZzQ0JCEBUVhcaNG2fbnZ6IqLiwCysRaZWjR48iIiICVatWRYMGDXI8TiqVon///li8eDE2bNiAhg0bQiqVYv369WjXrh38/f2xZcsW1KhRAyEhIbh8+TLGjBmDlStXZjv5RW4GDhyI//77D99//z0aNmyIevXqoVKlShBCICQkBP/++y9MTU0xYsQIxTn+/v64e/cuNmzYADc3N9SvXx+urq5ISUnBvXv3cPv2bdSpUweDBw/O970qinLnR/v27WFoaIglS5bg1q1bcHR0hEQiwZQpUz7aYlMYunXrhpo1a+LKlSuKcafv3r3DiRMnUK9ePTRr1gznz5/P9tymTZsiJSUFlStXRps2bZCamorjx48jKSkJgwYNyvYP/exMnz4dwcHB0NHRga6uLoYPH57tcXnpTtypUycEBgbi4sWLOY6lff36tWL8Z3YaNGiAcePGqfyeH7p8+TL69u2rmHTG0dER8fHxuHXrFkJDQyGRSDBv3jzUqVNH6bwxY8ZAIpFg0qRJ+PzzzzF58mQ0btwY1tbWePPmDZ48eYLbt28DyJg46cMxhWFhYbh37162EzzlVUREBPr37w8LCws0bNgQDg4OiImJwe3btxEaGgqpVIrFixejUaNGinMiIyPh4+MDmUwGV1dX/Prrr/j111+zXLtHjx7o0aOH0rZ169bB3d0dCxcuxJ49e1C7dm3cuXMHt2/fhpGRETZt2gQTE5Ms15L3qujcuXOB60xEVCDFt2IIEVHBeXt757iA+IcuX74sAAh7e3uRmpqq2H79+nXRpUsXYW5uLkxMTISHh4c4dOiQ2LhxowAg/P39la4jX4vwY2sLnjp1SvTt21c4OjoKPT09YWNjI+rUqSN8fX3FqVOnsj1n7969onPnzsLe3l7o6ekJe3t70bBhQzF16lRx9epVpWPl60A+fvw4y3UCAgJyvS/IZVH5vJT7Y/cip/c5cuSI8PDwEKampoo19lRZq/HDdSA/Jqd1IKOjo8Xo0aOFi4uLMDAwEBUrVhR+fn4iMTEx2/sqX0exVatWIiYmRnz11VfC0dFR6Ovri2rVqolFixaJtLQ0lcqUuR4fe+XFuXPnBADx1VdfZdmn6jqQ3bt3VzovL+WQyWQiODhYzJ49W3h6egoXFxdhaGgoDA0NRaVKlcTgwYPFuXPncr3Gs2fPxLRp08Qnn3wirKyshK6urrC0tBQNGjQQY8eOFRcuXMj2PPn9VOV7QIjc14GMjIwUc+fOFW3atBHly5cXBgYGwsjISFSpUkV8/vnnWf4fCqH6/c2pfJGRkWLMmDGiQoUKiv/3AwYMyHZNVrk2bdoIPT29bNeOJSIqThIhimnaOSIiDTdq1Cj8+uuv2Lp1K/r376/u4pAahYaGwtXVFa1atVJ5tk51qF+/Pp4/f47nz59nWc6GSo7nz5/D2dkZffr0wbZt29RdHCIq5TgGkohKlejoaMUaiJlt27YNa9euhaWlZZHMDElUFObNm4fXr18XylhV0lw//vgjpFKpYuwtEZE6cQwkEZUq9+/fh7u7O+rUqYOKFSsCyJhE4969e9DR0cGvv/6a7fgjIk3UqVMntG7dGj/88ANGjBjBVsgSKCwsDL/99htGjBhRLGOGiYg+hgkkEZUqFStWxJgxYxAUFIQTJ04gMTERtra26NWrFyZPngx3d3d1F5EoT4KCgtRdBCpCZcuWxdu3b9VdDCIiBY6BJCIiIiIiIpVwDCQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSQRERERERGphAkkERERERERqYQJJBEREREREamECSRRMZs9ezYkEom6i0FERKR1GEOJ1I8JJJVYgYGBkEgkSi97e3u0bt0ahw4dUnfxPurevXuYOHEimjVrBkNDQ0gkEoSGhqq7WEREVApoewzdtWsX+vfvj4oVK8LY2BjVqlXD//73P8TExKi7aERaT1fdBSAqanPnzoWrqyuEEIiIiEBgYCA6deqE/fv3o0uXLuouXo6Cg4OxbNky1KhRA25ubrh+/bq6i0RERKWMtsbQkSNHwtHREYMGDUKFChVw8+ZNrFixAgcPHsQ///wDIyMjdReRSGsxgaQSr2PHjvjkk08UPw8fPhxlypTBli1bNDr4devWDTExMTAzM8OiRYuYQBIRUbHT1hi6Y8cOeHp6Km1r2LAhhgwZgk2bNuGLL75QT8GISgB2YaVSx9LSEkZGRtDVVX5+smjRIjRr1gw2NjYwMjJCw4YNsWPHjiznSyQS+Pr6Ys+ePahVqxYMDAxQs2ZNHD58OMuxZ8+eRaNGjWBoaIhKlSrh119/Vbmc1tbWMDMzy3sFiYiIioi2xNAPk0cA6NmzJwDgzp07Kl+HiLJiCySVeLGxsXj9+jWEEIiMjMTy5cuRkJCAQYMGKR33888/o1u3bvDx8UFKSgq2bt2Kvn374sCBA+jcubPSsWfPnsWuXbvw1VdfwczMDMuWLUPv3r3x9OlT2NjYAABu3ryJ9u3bw87ODrNnz0ZaWhpmzZqFMmXKFFvdiYiICqIkxdDw8HAAgK2tbb6vQUQABFEJFRAQIABkeRkYGIjAwMAsxyclJSn9nJKSImrVqiXatGmjtB2A0NfXFw8fPlRsu3HjhgAgli9frtjWo0cPYWhoKJ48eaLYdvv2baGjoyPy+l/vxx9/FADE48eP83QeERFRfpSkGCo3fPhwoaOjI+7fv5+v84koA1sgqcRbuXIlqlatCgCIiIjAxo0b8cUXX8DMzAy9evVSHJd5QP2bN2+Qnp6OFi1aYMuWLVmu2a5dO1SqVEnxc506dWBubo5Hjx4BANLT03HkyBH06NEDFSpUUBzn5uYGLy8vHDx4sNDrSUREVNhKSgzdvHkz1q1bh6lTp6JKlSp5Pp+I3mMCSSVe48aNlSYA8Pb2Rv369eHr64suXbpAX18fAHDgwAF89913uH79OpKTkxXHZ7feVOaAJmdlZYU3b94AAF69eoW3b99mG6SqVavGBJKIiLRCSYihZ86cwfDhw+Hl5YV58+bl6VwiyoqT6FCpI5VK0bp1a4SFheHBgwcAMoJLt27dYGhoiF9++QUHDx7EsWPHMHDgQAghslxDR0cn22tndywREVFJoW0x9MaNG+jWrRtq1aqFHTt2ZJn8h4jyjv+LqFRKS0sDACQkJAAAdu7cCUNDQxw5cgQGBgaK4wICAvJ1fTs7OxgZGSmCa2b37t3L1zWJiIg0gbbE0JCQEHTo0AH29vY4ePAgTE1N81UeIlLGFkgqdVJTU3H06FHo6+vDzc0NQMbTUIlEgvT0dMVxoaGh2LNnT77eQ0dHB15eXtizZw+ePn2q2H7nzh0cOXKkQOUnIiJSF22JoeHh4Wjfvj2kUimOHDkCOzu7fJWFiLJiCySVeIcOHcLdu3cBAJGRkdi8eTMePHgAf39/mJubAwA6d+6MxYsXo0OHDhg4cCAiIyOxcuVKVK5cGf/++2++3nfOnDk4fPgwWrRoga+++gppaWlYvnw5atasqdI1Y2NjsXz5cgDAuXPnAAArVqyApaUlLC0t4evrm69yERERqUpbY2iHDh3w6NEjTJ06FWfPnsXZs2cV+8qUKYNPP/00X+UiInAZDyq5spuC3NDQUNSrV0+sWrVKyGQypePXrVsnqlSpIgwMDET16tVFQECAmDVrVpbpwgGIMWPGZHk/Z2dnMWTIEKVtp06dEg0bNhT6+vqiYsWKYvXq1dleMzuPHz/Odgp1AMLZ2TnP94OIiEhV2h5Dc4qfAESrVq3yfD+I6D2JEJz1g4iIiIiIiD6OYyCJiIiIiIhIJUwgiYiIiIiISCVMIImIiIiIiEglTCCJiIiIiIhIJUwgiYiIiIiISCVMIImIiIiIiEgluuouQEkmk8nw8uVLmJmZQSKRqLs4RFSIhBCIj4+Ho6MjpFI+iyMqbIyhRCUXY6h2YwJZhF6+fAknJyd1F4OIitCzZ89Qvnx5dReDqMRhDCUq+RhDtRMTyCJkZmYGALhz65ri30RUMsTHx8OtVn3+3yYqIoyhRCUXY6h2YwJZhORdbszMzDDUxV/NpSGiwrAreqXSz+xaR1Q0GEOJSh7G0JKBnY6JiIiIiIhIJUwgiYiIiIiISCVMIImIiIiIiEglHANJRKRB0tPTkZqaqu5iaB09PT3o6OiouxhERKRGjKH5k9cYygSSiEgDCCEQHh6OmJgYdRdFa1laWsLBwYGTMhARlTKMoQWXlxjKBJKISAPIA5+9vT2MjY2ZBOWBEAJJSUmIjIwEAJQtW1bNJSIiouLEGJp/+YmhTCCJiNQsPT1dEfhsbGzUXRytZGRkBACIjIyEvb09u7MSEZUSjKEFl9cYykl0iIjUTD5ew9jYWM0l0W7y+8fxL0REpQdjaOHISwxlAklEpCHY5aZgeP+IiEovxoCCycv9YwJJREREREREKmECSUREeRYaGgqJRILr168DAE6ePAmJRMIZ8IiIiD5C22MoE0giIg03dOhQSCSSLK8OHTqou2gKzZo1Q1hYGCwsLNRdFCIiIgXG0MLHWViJiLRAhw4dEBAQoLTNwMBATaXJSl9fHw4ODuouBhERURaMoYWLLZBERFrAwMAADg4OSi8rKysAGQPf165di549e8LY2BhVqlTBvn37lM7/77//0KVLF5ibm8PMzAwtWrRASEgIAEAmk2Hu3LkoX748DAwMUK9ePRw+fFjp/EuXLqF+/fowNDTEJ598gmvXrint/7D7TWBgICwtLXHkyBG4ubnB1NQUHTp0QFhYmOKctLQ0jBs3DpaWlrCxsYGfnx+GDBmCHj16KI7ZsWMHateuDSMjI9jY2KBdu3ZITEwsrNtKRESlAGNo4cZQJpBERCXAnDlz0K9fP/z777/o1KkTfHx8EB0dDQB48eIFWrZsCQMDAwQFBeHq1av4/PPPkZaWBgD4+eef8dNPP2HRokX4999/4eXlhW7duuHBgwcAgISEBHTp0gU1atTA1atXMXv2bEyePPmjZUpKSsKiRYuwYcMGnD59Gk+fPlU6b8GCBdi0aRMCAgJw7tw5xMXFYc+ePYr9YWFh8Pb2xueff447d+7g5MmT6NWrF4QQhXjniIiotGMMzRt2YSUi0gIHDhyAqamp0ravv/4aX3/9NYCMMR7e3t4AgO+//x7Lli3DpUuX0KFDB6xcuRIWFhbYunUr9PT0AABVq1ZVXGfRokXw8/PDgAEDAGQEpRMnTmDp0qVYuXIlNm/eDJlMhnXr1sHQ0BA1a9bE8+fPMXr06FzLnJqaitWrV6NSpUoAAF9fX8ydO1exf/ny5Zg2bRp69uwJAFixYgUOHjyo2B8WFoa0tDT06tULzs7OAIDatWvn/eYREVGpxhhauDGUCSQRkRZo3bo1Vq1apbTN2tpa8e86deoo/m1iYgJzc3NERkYCAK5fv44WLVooAl9mcXFxePnyJTw8PJS2e3h44MaNGwCAO3fuoE6dOjA0NFTsd3d3/2iZjY2NFYEPAMqWLasoU2xsLCIiItC4cWPFfh0dHTRs2BAymQwAULduXbRt2xa1a9eGl5cX2rdvjz59+ii6HREREamCMbRwYyi7sBIRaQETExNUrlxZ6ZU5+H0Y2CQSiSKIGBkZFWtZ5bIrU166zujo6ODYsWM4dOgQatSogeXLl6NatWp4/PhxYReViIhKMMbQwo2hTCCJiEq4OnXq4MyZM0hNTc2yz9zcHI6Ojjh37pzS9nPnzqFGjRoAADc3N/z777949+6dYv+FCxcKVCYLCwuUKVMGly9fVmxLT0/HP//8o3ScRCKBh4cH5syZg2vXrkFfXx+7d+8u0HsTERGpijE0KyaQRERaIDk5GeHh4Uqv169fq3Sur68v4uLiMGDAAFy5cgUPHjzAhg0bcO/ePQDAlClTsGDBAmzbtg337t2Dv78/rl+/jvHjxwMABg4cCIlEghEjRuD27ds4ePAgFi1aVOA6jR07FvPnz8fevXtx7949jB8/Hm/evIFEIgEAXLx4Ed9//z2uXLmCp0+fYteuXXj16hXc3NwK/N5ERFR6MIYWbgzlGEgiIi1w+PBhlC1bVmlbtWrVcPfu3Y+ea2Njg6CgIEyZMgWtWrWCjo4O6tWrpxizMW7cOMTGxuJ///sfIiMjUaNGDezbtw9VqlQBAJiammL//v0YNWoU6tevjxo1amDBggXo3bt3gerk5+eH8PBwfPbZZ9DR0cHIkSPh5eUFHR0dABlPdk+fPo2lS5ciLi4Ozs7O+Omnn9CxY8cCvS8REZUujKGFG0MlgvOhF5m4uDhYWFjg+ZOHGOrir+7iEFEh2BW9EgAQFxeP8s6VERsbC3Nz8wJd8927d3j8+DFcXV2VBtmXNjKZDG5ubujXrx++/fbbPJ/P+1iyMIYSlTyMoUWnOGMoWyCJiEgtnjx5gqNHj6JVq1ZITk7GihUr8PjxYwwcOFDdRSMiItJo6oyhHANJRERqIZVKERgYiEaNGsHDwwM3b97E33//zTGOREREH6HOGMoWSCIiUgsnJ6csM9cRERHRx6kzhrIFkoiIiIiIiFSi1gRy/vz5aNSoEczMzGBvb48ePXoopsSVCwkJQc+ePWFnZwdzc3P069cPERERuV539uzZkEgkSq/q1atnOS44OBht2rSBiYkJzM3N0bJlS7x9+1ax38XFJct1fvjhh8KpPBERUQEwhhIRkTqoNYE8deoUxowZgwsXLuDYsWNITU1F+/btkZiYCABITExE+/btIZFIEBQUhHPnziElJQVdu3aFTCbL9do1a9ZEWFiY4nX27Fml/cHBwejQoQPat2+PS5cu4fLly/D19YVUqnxL5s6dq3SdsWPHFu5NICIiygfGUCIiUge1joE8fPiw0s+BgYGwt7fH1atX0bJlS5w7dw6hoaG4du2aYorf9evXw8rKCkFBQWjXrl2O19bV1YWDg0OO+ydOnIhx48bB3//91ODVqlXLcpyZmVmu1yEiIlIHxlAiIlIHjRoDGRsbCwCwtrYGACQnJ0MikcDAwEBxjKGhIaRSaZanoR968OABHB0dUbFiRfj4+ODp06eKfZGRkbh48SLs7e3RrFkzlClTBq1atcr2mj/88ANsbGxQv359/Pjjj0hLSyuMqhIRERUqxlAiIioOGpNAymQyTJgwAR4eHqhVqxYAoGnTpjAxMYGfnx+SkpKQmJiIyZMnIz09HWFhYTleq0mTJggMDMThw4exatUqPH78GC1atEB8fDwA4NGjRwAyxnmMGDEChw8fRoMGDdC2bVs8ePBAcZ1x48Zh69atOHHiBL788kt8//33mDp1ao7vm5ycjLi4OKUXERFRUWMMJSKi4qIxy3iMGTMGt27dUnqCaWdnhz///BOjR4/GsmXLIJVK4e3tjQYNGmQZZ5FZx44dFf+uU6cOmjRpAmdnZ2zfvh3Dhw9XjP348ssvMWzYMABA/fr1cfz4cfz++++YP38+AGDSpElK19HX18eXX36J+fPnKz3RlZs/fz7mzJlTsBtBRJRJ5NNXiH0dX2zvZ2FrBvsKdsX2flQ4GEOJiLJiDC0aGpFA+vr64sCBAzh9+jTKly+vtK99+/YICQnB69evoaurC0tLSzg4OKBixYoqX9/S0hJVq1bFw4cPAQBly5YFANSoUUPpODc3N6VuOh9q0qQJ0tLSEBoamu1Yj2nTpikFzLi4ODg5OalcTiKizCKfvsLQ6uOR+i612N5Tz1APgXd/VjkApqenY/bs2di4cSPCw8Ph6OiIoUOHYsaMGZBIJDmed/LkSUyaNAn//fcfnJycMGPGDAwdOrSQalG6MIYSEWXFGFp01NqFVQgBX19f7N69G0FBQXB1dc3xWFtbW1haWiIoKAiRkZHo1q2byu+TkJCAkJAQRdBzcXGBo6NjlunO79+/D2dn5xyvc/36dUilUtjb22e738DAAObm5kovIqL8in0dX6yBDwBS36Xm6WntggULsGrVKqxYsQJ37tzBggULsHDhQixfvjzHcx4/fozOnTujdevWuH79OiZMmIAvvvgCR44cKYwqlBqMoUREOWMMLTpqbYEcM2YMNm/ejL1798LMzAzh4eEAAAsLCxgZGQEAAgIC4ObmBjs7OwQHB2P8+PGYOHGi0tPLtm3bomfPnvD19QUATJ48GV27doWzszNevnyJWbNmQUdHB97e3gAAiUSCKVOmYNasWahbty7q1auH9evX4+7du9ixYweAjCnKL168iNatW8PMzAzBwcGYOHEiBg0aBCsrq+K8TUREGuv8+fPo3r07OnfuDCAjudiyZQsuXbqU4zmrV6+Gq6srfvrpJwAZLVdnz57FkiVL4OXlVSzlLgkYQ4mItJu2xlC1JpCrVq0CAHh6eiptDwgIUDTD3rt3D9OmTUN0dDRcXFwwffp0TJw4Uel4efccuefPn8Pb2xtRUVGws7ND8+bNceHCBdjZvW9OnjBhAt69e4eJEyciOjoadevWxbFjx1CpUiUAGU9Ct27ditmzZyM5ORmurq6YOHGiUvcaIqLSrlmzZvjtt99w//59VK1aFTdu3MDZs2exePHiHM8JDg7OsoSEl5cXJkyYUMSlLVkYQ4mItJu2xlC1JpBCiI8e88MPP+CHH37I9ZjQ0FCln7du3arS+/v7+yutYZVZgwYNcOHCBZWuQ0RUWvn7+yMuLg7Vq1eHjo4O0tPTMW/ePPj4+OR4Tnh4OMqUKaO0rUyZMoiLi8Pbt28VrWeUO8ZQIiLtpq0xVCMm0SEiIu20fft2bNq0CZs3b0bNmjUV4zEcHR0xZMgQdRePiIhIY2lrDGUCSURE+TZlyhT4+/tjwIABAIDatWvjyZMnmD9/fo7Bz8HBAREREUrbIiIiYG5uztZHIiIqNbQ1hqp1FlYiItJuSUlJWdYU1NHRUawVmB13d3ccP35caduxY8fg7u5eJGUkIiLSRNoaQ5lAEhWi0Q8eYvSDh+ouBlGx6dq1K+bNm4e//voLoaGh2L17NxYvXoyePXsqjpk2bRo+++wzxc+jRo3Co0ePMHXqVNy9exe//PILtm/fnmVyFyIqXZ7vrIXnO2upuxhExUZbYyi7sBYDVSY6ICL6kIWtGfQM9Yp9EWQLWzOVj1++fDlmzpyJr776CpGRkXB0dMSXX36Jb775RnFMWFiY0gLzrq6u+OuvvzBx4kT8/PPPKF++PNauXcslPChbjKFElB+MoUWHCWQxeJecrO4iEJEWsq9gh8C7P+dpUeKCsrA1g30Fu48f+P/MzMywdOlSLF26NMdjAgMDs2zz9PTEtWvX8lFCKm0YQ4koPxhDiw4TyGKgq8vbrOkKu9tpYVxvVZXKhVAS0nb2FezyFIyIShrGUM1X2N1OC+N65XvfKoSSkLZjDC0aHANZDHR1dNRdBCIiIq3EGEpEpFn4WK8YSCQSdReBUPitjEXtY+VlCyURlQaMoZpB2ya3+Vh52UJJlH9sgSQiIiIiIiKVsAWSSgxta2EsqNzqy9ZJIiLKC21rYSyo3OrL1kmi3LEFkoiIiIiIiFTCFkjSeqWt5VEVme8JWyOJiCgnpa3lURWZ7wlbI4myYgskERERERERqYQtkKRV2NqYd9ndM7ZKEhGVPmxtzLvs7hlbJam0YwJJRKTBXibF4k1KUrG9n5W+MRyNLYrt/YiIiIoKY2jRYAJJGoutjUWHrZLa4WVSLDoeW4EUWVqxvae+VBeHPvXNUwA8ffo0fvzxR1y9ehVhYWHYvXs3evToodifkJAAf39/7NmzB1FRUXB1dcW4ceMwatSoXK/7559/YubMmQgNDUWVKlWwYMECdOrUKb9VIypV2NpYdNgqqR0YQ4suhnIMJBGRhnqTklSsgQ8AUmRpeX5am5iYiLp162LlypXZ7p80aRIOHz6MjRs34s6dO5gwYQJ8fX2xb9++HK95/vx5eHt7Y/jw4bh27Rp69OiBHj164NYt/pFGREQfxxhadDGUCSQRERVIx44d8d1336Fnz57Z7j9//jyGDBkCT09PuLi4YOTIkahbty4uXbqU4zV//vlndOjQAVOmTIGbmxu+/fZbNGjQACtWrCiqahARERU7bYyhTCBJ44x+8JDdV9WA952KSrNmzbBv3z68ePECQgicOHEC9+/fR/v27XM8Jzg4GO3atVPa5uXlheDg4KIuLpFWe76zFruvqgHvOxUVTYyhHANJRERFavny5Rg5ciTKly8PXV1dSKVSrFmzBi1btszxnPDwcJQpU0ZpW5kyZRAeHl7UxSUiItIYmhhDmUCSRmDLl+bI/FlwYh0qDMuXL8eFCxewb98+ODs74/Tp0xgzZgwcHR2zPCElorxjy5fmyPxZcGIdKgyaGEOZQBIRUZF5+/Ytvv76a+zevRudO3cGANSpUwfXr1/HokWLcgx+Dg4OiIiIUNoWEREBBweHIi8zERGRJtDUGMoxkKRWHHen2fj5UEGlpqYiNTUVUqlyuNHR0YFMJsvxPHd3dxw/flxp27Fjx+Du7l4k5STSRhx3p9n4+VBBaWoMZQskEREVSEJCAh4+fP+g4fHjx7h+/Tqsra1RoUIFtGrVClOmTIGRkRGcnZ1x6tQp/PHHH1i8eLHinM8++wzlypXD/PnzAQDjx49Hq1at8NNPP6Fz587YunUrrly5gt9++63Y60dERFRUtDGGMoGkYscWrfzrYZKo+PeeRJNie1+Oi1QPK31j6Et1i30RZCt94zydc+XKFbRu3Vrx86RJkwAAQ4YMQWBgILZu3Ypp06bBx8cH0dHRcHZ2xrx585QWQX769KnSE9ZmzZph8+bNmDFjBr7++mtUqVIFe/bsQa1afJpPpRtbtPLvP/dNin/XDPYptvfluEj1YAwtuhjKBJKISEM5Glvg0Ke+eV6UuCCs9I3haGyRp3M8PT0hhMhxv4ODAwICAnK9xsmTJ7Ns69u3L/r27ZunshAREQGMoUUZQ5lAUrEp7S2PmVsPNeV6+WnFlH+ObIksHo7GFnkORkRU8pT2lsfMrYeacr38tGLKP0e2RBYPxtCiwUl0iIiIiIiISCVMIImIiIiIiEgl7MJKRaq0dVst7G6qRe1j5c2tiysn1iEiKlqlrdtqYXdTLWofK29uXVw5sQ5pM7ZAEhERERERkUrYAkmUB9rWwlhQudW3OJcRISIi7adtLYwFlVt9i3MZEaLCxhZIIiIiIiIiUglbIKlIlLSxj6Wt5VEVSveES3sQERWakjb2sbS1PKoi8z2puTOjNZJjIUlbMIEkItJgSalhSJbFFNv7GUgtYaxXttjej4iIqKgwhhYNJpBEH2BrY97J79l0zipXqJJSw3D0WQ/IREqxvadUoo/2TntUDoDz58/Hrl27cPfuXRgZGaFZs2ZYsGABqlWrBgCIjo7GrFmzcPToUTx9+hR2dnbo0aMHvv32W1hY5Ly4sxACs2bNwpo1axATEwMPDw+sWrUKVapUKZR6ElHRYGtj3snv2Z4H7+cWYI+egmMMLboYyjGQREQaKlkWU6yBDwBkIiVPT2tPnTqFMWPG4MKFCzh27BhSU1PRvn17JCZmPFR4+fIlXr58iUWLFuHWrVsIDAzE4cOHMXz48Fyvu3DhQixbtgyrV6/GxYsXYWJiAi8vL7x7964g1SMiolKCMbToYihbIKnQaOO4R7Y2Fq7sxnRkxlbJkufw4cNKPwcGBsLe3h5Xr15Fy5YtUatWLezcuVOxv1KlSpg3bx4GDRqEtLQ06OpmDUNCCCxduhQzZsxA9+7dAQB//PEHypQpgz179mDAgAFFWykiNdDGcY9sbSxc2c0tkBlbJUsebY2hbIEkIqJCExsbCwCwtrbO9Rhzc/NsAx8APH78GOHh4WjXrp1im4WFBZo0aYLg4ODCLTAREZGG0JYYyhZIKjBta3lkq2PxkD+ZzrzWlfwJO1siSyaZTIYJEybAw8MDtWpl35ry+vVrfPvttxg5cmSO1wkPDwcAlClTRml7mTJlFPuISgpta3lkq2PxkP+tknnN5dGc8bxE06YYygSSiIgKxZgxY3Dr1i2cPXs22/1xcXHo3LkzatSogdmzZxdv4YiIiDSYNsVQdmElIqIC8/X1xYEDB3DixAmUL18+y/74+Hh06NABZmZm2L17N/T09HK8loODAwAgIiJCaXtERIRiHxERUUmhbTGULZBUarDrquZ4zuU+SgwhBMaOHYvdu3fj5MmTcHV1zXJMXFwcvLy8YGBggH379sHQ0DDXa7q6usLBwQHHjx9HvXr1FNe4ePEiRo8eXRTVIKKPYNdVzZF56BC7s2o3bY2h+W6BDAkJwYwZM+Dt7Y3IyEgAwKFDh/Dff/8VSsGIiEjzjRkzBhs3bsTmzZthZmaG8PBwhIeH4+3btwAygpZ8SvJ169YhLi5OcUx6erriOtWrV8fu3bsBABKJBBMmTMB3332Hffv24ebNm/jss8/g6OiIHj16qKOahY4xlIiItDWG5qsF8tSpU+jYsSM8PDxw+vRpzJs3D/b29rhx4wbWrVuHHTt2FErhiAqKrY6ajxPraLdVq1YBADw9PZW2BwQEYOjQofjnn39w8eJFAEDlyspPyh8/fgwXFxcAwL179xSzzwHA1KlTkZiYiJEjRyImJgbNmzfH4cOHP/rkVRswhpK2YKuj5uPEOtpNW2NovhJIf39/fPfdd5g0aRLMzMwU29u0aYMVK1YUSsGIiEo7A6klpBL9Yl0IWSrRh4HUUuXjhRC57vf09PzoMdldRyKRYO7cuZg7d67KZdEWjKFEREWPMbToYmi+EsibN29i8+bNWbbb29vj9evXBS4UaT5NX7qDLY+aI/MT7MxLenyILZFZGeuVRXunPUiWxRTbexpILWGsV7bY3q80YgwlTV+6gy2PmiPz3zOZl/T4EFsis2IMLTr5SiAtLS0RFhaWZaDntWvXUK5cuUIpGBERZQRAY5T8YFSaMIYSERUPxtCika9JdAYMGAA/Pz+Eh4dDIpFAJpPh3LlzmDx5Mj777DOVrzN//nw0atQIZmZmsLe3R48ePXDv3j2lY0JCQtCzZ0/Y2dnB3Nwc/fr1yzIt7Ydmz54NiUSi9KpevXqW44KDg9GmTRuYmJjA3NwcLVu2VAxaBYDo6Gj4+PjA3NwclpaWGD58OBISElSuHxWvHiaJihdpr+c7ayleRCURYyhpov/cNylepL1GP3ioeBEVlXwlkN9//z2qV68OJycnJCQkoEaNGmjZsiWaNWuGGTNmqHydU6dOYcyYMbhw4QKOHTuG1NRUxUxDAJCYmIj27dtDIpEgKCgI586dQ0pKCrp27QqZTJbrtWvWrImwsDDF68NFOYODg9GhQwe0b98ely5dwuXLl+Hr6wup9P0t8fHxwX///Ydjx47hwIEDOH36NEaOHJmHO0VERKSMMZSIiLRZvrqw6uvrY82aNZg5cyZu3bqFhIQE1K9fH1WqVMnTdQ4fPqz0c2BgIOzt7XH16lW0bNkS586dQ2hoKK5duwZzc3MAwPr162FlZYWgoCC0a9cux2vr6urmuljmxIkTMW7cOPj7+yu2VatWTfHvO3fu4PDhw7h8+TI++eQTAMDy5cvRqVMnLFq0CI6OjnmqKxUdtjiWXBwXSSURYyhjqCZhi2PJxXGRVFTyvQ4kAFSoUAGdOnVCv3798hz4siOfftba2hoAkJycDIlEAgMDA8UxhoaGkEqlWZ6GfujBgwdwdHRExYoV4ePjg6dPnyr2RUZG4uLFi7C3t0ezZs1QpkwZtGrVSumawcHBsLS0VAQ+AGjXrh2kUqliOt0PJScnIy4uTulFRESUHcZQZYyhRETaQeUWyEmTJql80cWLF+e5IDKZDBMmTICHhwdq1cpodWjatClMTEzg5+eH77//HkII+Pv7Iz09HWFhYTleq0mTJggMDES1atUQFhaGOXPmoEWLFrh16xbMzMzw6NEjABnjPBYtWoR69erhjz/+QNu2bXHr1i1UqVIF4eHhsLe3V7qurq4urK2tER4enu37zp8/H3PmzMlz3bUJ+9RTQcifdOc2GytRScQYyhgKaP7sq6TZ5D2ucpuNlag4qJxAXrt2Tennf/75B2lpaYouK/fv34eOjg4aNmyYr4KMGTMGt27dUnqCaWdnhz///BOjR4/GsmXLIJVK4e3tjQYNGiiNs/hQx44dFf+uU6cOmjRpAmdnZ2zfvh3Dhw9XjP348ssvMWzYMABA/fr1cfz4cfz++++YP39+vuowbdo0pT8S4uLi4OTklK9rERFRycEY+nGMoURE2kHlBPLEiROKfy9evBhmZmaKsRQA8ObNGwwbNgwtWrTIcyF8fX0VA+zLly+vtK99+/YICQnB69evoaurC0tLSzg4OKBixYoqX9/S0hJVq1bFw4cZrWdly2ZM51ujRg2l49zc3BTddBwcHBAZGam0Py0tDdHR0TmOCzEwMFDqKkRERAQwhgKMoUREJUW+JtH56aefcPToUUXgAwArKyt89913aN++Pf73v/+pdB0hBMaOHYvdu3fj5MmTWdbEyszW1hYAEBQUhMjISHTr1k3l8iYkJCAkJASDBw8GALi4uMDR0THLdOf3799XPHl1d3dHTEwMrl69qngiHBQUBJlMhiZNmqj83lQ0OHFO6ZK521dpm1BHpL8EZG+K7w2lVpDocIKTosQYyhiqbpw4p3TJPPyotE2owxhaNPKVQMbFxeHVq1dZtr969Qrx8fEqX2fMmDHYvHkz9u7dCzMzM8W4CAsLCxgZGQEAAgIC4ObmBjs7OwQHB2P8+PGYOHGi0mxvbdu2Rc+ePeHr6wsAmDx5Mrp27QpnZ2e8fPkSs2bNgo6ODry9vQEAEokEU6ZMwaxZs1C3bl3Uq1cP69evx927d7Fjxw4AGU9SO3TogBEjRmD16tVITU2Fr68vBgwYwNnjiKhYiPSXEK/aA0gpxnfVB+yOqhwA58+fj127duHu3bswMjJCs2bNsGDBAqXvaDkhBDp16oTDhw9j9+7d6NGjR47XFUJg1qxZWLNmDWJiYuDh4YFVq1YVymQz6sYYyhhKREWPMbToYmi+ZmHt2bMnhg0bhl27duH58+d4/vw5du7cieHDh6NXr14qX2fVqlWIjY2Fp6cnypYtq3ht27ZNccy9e/fQo0cPuLm5Ye7cuZg+fToWLVqkdB159xy558+fw9vbG9WqVUO/fv1gY2ODCxcuwM7OTnHMhAkTMG3aNEycOBF169bF8ePHcezYMVSqVElxzKZNm1C9enW0bdsWnTp1QvPmzfHbb7/l55YREeWd7A2KN/Ah4/3y8LT2Y2sRZrZ06VJIJBKVrrtw4UIsW7YMq1evxsWLF2FiYgIvLy+8e/dO5bJpKsZQIqJiwBhaZDFUIoQQeT0pKSkJkydPxu+//47U1FQAGbOrDR8+HD/++CNMTDg7FJDxlNnCwgLPnzzEUBf/j5+gBTRlFlZ2YdVuBZmFVd1dWHdFrwQAxMXFo7xzZcTGxirW2Muvd+/e4fHjx3B1dYWhoaFiu0j9DyKqZ4GunR8Sm92Q6NXM17mvXr2Cvb09Tp06hZYtWyq2X79+HV26dMGVK1dQtmzZXJ+eCiHg6OiI//3vf5g8eTKAjCUqypQpg8DAQAwYMCDb83K6j5qGMVQ1JTGGasosrOzCqt0KMgururuwMobmTltiaL66sBobG+OXX37Bjz/+iJCQEABApUqVGPSoyDFxJPkfYOpOJCl7H65FCGQkTAMHDsTKlStzXZxe7vHjxwgPD1da6N7CwgJNmjRBcHBwjsFPWzCGkrowcSR5Q4C6E0nKnrbE0HwlkHImJiaoU6dOgQtBRETaL7u1CAFg4sSJaNasGbp3767SdeRj+cqUKaO0vUyZMjmuIaiNGEOJiEhOm2JovhLI1q1b59oHNygoKN8FIvoQWx0pO6V5ZlZNld1ahPv27UNQUFCWdRBLM8ZQKk5sdaTslOaZWTWVNsXQfE2iU69ePdStW1fxqlGjBlJSUvDPP/+gdu3ahV1GIiLScPK1CE+cOKG0FmFQUBBCQkJgaWkJXV1d6OpmPLfs3bs3PD09s72WvItORESE0vaIiAiVuu9oOsZQIiLKTNtiaL5aIJcsWZLt9tmzZyMhIaFABSIiIu3xsbUI/f398cUXXyhtq127NpYsWYKuXbtme01XV1c4ODjg+PHjqFevHoCMCVUuXryI0aNHF0k9ihNjKBERAdobQws0BvJDgwYNQuPGjbNMEU5ERCXTx9YidHBwyPaJZ4UKFZQCZfXq1TF//nz07NkTEokEEyZMwHfffYcqVarA1dUVM2fOhKOjY67rXmk7xlAiotJFW2NooSaQwcHBGj11OhERFa5Vq1YBQJauNAEBARg6dKjK17l3755i9jkAmDp1KhITEzFy5EjExMSgefPmOHz4cImOMYyhRESli7bG0HwlkB8udCyEQFhYGK5cuYKZM2cWSsGIiEo9qRUAfRTvQsj6//++qsnHUsLZnvPhNolEgrlz52Lu3Ll5vr6mYwwlIioGjKFFFkPzlUCam5srzSAnlUpRrVo1zJ07F+3bty+0whERlWYSHUfA7igge1N8byq1ynhfKjKMoURERY8xtOjkK4EMDAws5GKQJss81XNx4vIdJVfmaeVrBvsU+HryJT1K4nIeEh1HoBQEo9KEMbR0ybzkUHHi8h0lV+a/j/YkmhT4evK/80rich6MoUUjX8t4VKxYEVFRUVm2x8TEoGLFigUuFBERUUnFGEpERNosXy2QoaGhSE9Pz7I9OTkZL168KHChSLNkfiKlrtZIKlkKo9WRSFsxhpYumXtGqKs1kkqWwmh1JCqIPCWQ+/btU/z7yJEjsLCwUPycnp6O48ePw8XFpdAKR0REVFIwhhIRUUmQpwRSvnaIRCLBkCFDlPbp6enBxcUFP/30U6EVjoioNMnPbGz0nqbfP8ZQIqKio+kxQNPl5f7lKYGUyWQAAFdXV1y+fBm2trZ5KxkREWWhp6cHAEhKSoKRkZGaS6O9kpKSALy/n5qGMZSIqPAxhhaOvMTQfI2BfPz4cX5OK7XSZXwikhecfZXyK/P4Im2akVVHRweWlpaIjIwEABgbGyst80C5E0IgKSkJkZGRsLS0hI6OjrqLlCvG0LxhDM0bzr5K+ZV5ngttmpGVMbRg8hNDVU4gly1bhpEjR8LQ0BDLli3L9dhx48apetlSwcDIVN1FICIN5+DgAACKAEh5Z2lpqbiPmoYxNP8YQ4noYxhDCy4vMVTlBHLJkiXw8fGBoaEhlixZkuNxEomEwe8DyW/ZokZEuZNIJChbtizs7e2Rmpqq7uJoHT09PY1ueWQMzT/GUCL6GMbQgslrDFU5gczc5Ybdb/JGJ1+rbRJRaaSjo6PRiRDlD2No/jGGEpGqGEOLR76+lufOnasYaJnZ27dvMXfu3AIXioiIqKRiDCUiIm2WrwRyzpw5SEhIyLI9KSkJc+bMKXChiIiISirGUCIi0mb5SiCFENnObnTjxg1YW1sXuFBEREQlFWMoERFpszwt42FlZQWJRAKJRIKqVasqBcD09HQkJCRg1KhRhV5IIiIibccYSkREJUGeEsilS5dCCIHPP/8cc+bMgYWFhWKfvr4+XFxc4O7uXuiFJCIi0naMoUREVBLkKYEcMmQIAMDV1RXNmjWDnp5ekRSKiIiopGEMJSKikiBPCaRcq1atFP9+9+4dUlJSlPabm5sXrFREREQlFGMoERFps3wlkElJSZg6dSq2b9+OqKioLPvT09MLXDDSTKuqVAYAjH7wUM0lIW1UM9hH3UUgUjvG0NKrfO9bAIDnO2upuSSkjfYkmqi7CEQA8jkL65QpUxAUFIRVq1bBwMAAa9euxZw5c+Do6Ig//vijsMtIRERUYjCGEhGRNstXC+T+/fvxxx9/wNPTE8OGDUOLFi1QuXJlODs7Y9OmTfDxYSsDERFRdhhDiYhIm+WrBTI6OhoVK1YEkDFWIzo6GgDQvHlznD59uvBKR0REVMIwhhIRkTbLVwJZsWJFPH78GABQvXp1bN++HUDGU9XM05ITERGRMsZQIiLSZvnqwjps2DDcuHEDrVq1gr+/P7p27YoVK1YgNTUVixcvLuwyUinQwyRR3UWgEkY+SYV80goiTcEYSoXtP/dN6i4ClTDyyRLlkycSZZavBHLixImKf7dr1w53797F1atXYWtri40bNxZa4YiIiEoaxlAiItJmEiGEKKyL3bhxAw0aNOAU5P8vLi4OFhYWeP7kIYa6+Ku7OEWmsJf0YGtkyaKupTuKquVxV/RKAEBcXDzKO1dGbGws1+2jQsEYqqy0xNDCXtKDrZEli7qW7iiqlkfG0JIhX2MgiYiIiIiIqPRhAklEREREREQqYQJJREREREREKsnTJDq9evXKdX9MTExBykJERFRiMYYSEVFJkKcE8mPrU1lYWOCzzz4rUIGIiIhKIsZQIiIqCfKUQAYEBBRVOUiLyWfqKuzZWEm7qWv2VSJNxRhK2ZHPGF3Ys7GSdlPX7KtEquAYSCIiIiIiIlJJnlogiXKTec0gtkaWTmx1JCLKn8xr17I1snRiqyNpC7ZAEhERERERkUqYQBIREREREZFKmEASERERERGRSphAEhERERERkUo4iQ4VCS7tUbpw8hwiosLDpT1KF06eQ9qGLZBERERERESkErUmkPPnz0ejRo1gZmYGe3t79OjRA/fu3VM6JiQkBD179oSdnR3Mzc3Rr18/RERE5Hrd2bNnQyKRKL2qV6+udIynp2eWY0aNGqV0zIf7JRIJtm7dWjiVpxztSTTh0zjKl/K9byleRCUdYyhlp2awD3uFUL6sqlJZ8SLKjVoTyFOnTmHMmDG4cOECjh07htTUVLRv3x6JiYkAgMTERLRv3x4SiQRBQUE4d+4cUlJS0LVrV8hkslyvXbNmTYSFhSleZ8+ezXLMiBEjlI5ZuHBhlmMCAgKUjunRo0eh1J2IiKggGEOJiEgd1DoG8vDhw0o/BwYGwt7eHlevXkXLli1x7tw5hIaG4tq1azA3NwcArF+/HlZWVggKCkK7du1yvLauri4cHBxyfX9jY+OPHmNpafnRYyhnmZ9icTxkycIn3ETqxRha8mXuTcHxkCULe1qRNtOoMZCxsbEAAGtrawBAcnIyJBIJDAwMFMcYGhpCKpVm+zQ0swcPHsDR0REVK1aEj48Pnj59muWYTZs2wdbWFrVq1cK0adOQlJSU5ZgxY8bA1tYWjRs3xu+//w4hRI7vmZycjLi4OKUXERFRcWAMJSKi4qAxs7DKZDJMmDABHh4eqFUr4ylb06ZNYWJiAj8/P3z//fcQQsDf3x/p6ekICwvL8VpNmjRBYGAgqlWrhrCwMMyZMwctWrTArVu3YGZmBgAYOHAgnJ2d4ejoiH///Rd+fn64d+8edu3apbjO3Llz0aZNGxgbG+Po0aP46quvkJCQgHHjxmX7vvPnz8ecOXMK8a6ULJyZtWRgyyOR5mEMLfk4M2vJwJZHKgkkIrfHgcVo9OjROHToEM6ePYvy5csrth89ehSjR4/G48ePIZVK4e3tjdu3b6Nx48ZYtWqVSteOiYmBs7MzFi9ejOHDh2d7TFBQENq2bYuHDx+iUqVK2R7zzTffICAgAM+ePct2f3JyMpKTkxU/x8XFwcnJCc+fPMRQF3+VyloaqJpA9jBJLOKSUH5ocgJZHJPn7IpeCQCIi4tHeefKiI2NVXQPJFIXxtDSQ9UE8j/3TUVcEsoPTU4gi2PyHMbQkkEjWiB9fX1x4MABnD59WinwAUD79u0REhKC169fQ1dXVzGeomLFiipf39LSElWrVsXDhzknLk2aNAGAXINfkyZN8O233yI5OVmpS5CcgYFBtttJmarjIuVfskwk1U+Tk0ageBJHIk3FGFq6qDouUv69zURS/TQ5aQSKJ3GkkkWtYyCFEPD19cXu3bsRFBQEV1fXHI+1tbWFpaUlgoKCEBkZiW7duqn8PgkJCQgJCUHZsmVzPOb69esA8NFjrKysGOCIiEjtGEOJiEgd1NoCOWbMGGzevBl79+6FmZkZwsPDAQAWFhYwMjICkDEFuJubG+zs7BAcHIzx48dj4sSJqFatmuI6bdu2Rc+ePeHr6wsAmDx5Mrp27QpnZ2e8fPkSs2bNgo6ODry9vQFkrIu1efNmdOrUCTY2Nvj3338xceJEtGzZEnXq1AEA7N+/HxEREWjatCkMDQ1x7NgxfP/995g8eXJx3iIiIqJsMYYSEZE6qDWBlI+/8PT0VNoeEBCAoUOHAgDu3buHadOmITo6Gi4uLpg+fTomTpyodLy8e47c8+fP4e3tjaioKNjZ2aF58+a4cOEC7OzsAAD6+vr4+++/sXTpUiQmJsLJyQm9e/fGjBkzFNfQ09PDypUrMXHiRAghULlyZSxevBgjRowogjtRenFiHc2m6V1XiUozxlDixDqaTdO7rhLll8ZMolMSxcXFwcLCghMAqCC3BJJjINVHWxLI4hwDyQkAiIoHY6jqcksgOQZSfbQlgSzOMZCMoSWDRkyiQ6TqxDpU9LQlaSQiogyqTqxDRU9bkkaiglDrJDpERERERESkPdgCSRrnw3GRmZ/msTtr0dG2lkcu3UFElNWH4yIzf7ezO2vR0baWRy7dQQXBFkgiIiIiIiJSCVsgSWNl+3Ts/1sl2RJZMNrW2pgZWx6JiD4uu+/KmjszvvvZElkw2tbamBlbHqkwsAWSiIiIiIiIVMIWSNIq8idn0zPNMscnqbnT5tZGIiIqPPJWyT0POLeAqrS5tZGoqLAFshhwqU0iIqL8YQwlItIsTCCJiIiIiIhIJezCSlop8+QAnBQgq5LWbZUT5xARFR6liVQ4OV0WJa3bKifOocLGFkgiIiIiIiJSCVsgqcT4WKtbSWuhLGmtjEREpD4fa3UraS2UJa2Vkag4sQWSiIiIiIiIVMIWSNJ68vFxzzMt7ZGd3FrsNLF1ki2MHPtIRFTU5OPjRv//WMic5NZip4mtk2xh5NhHKjpsgSwGEolE3UUgIiLSSoyhRESahS2QVGJkbq36WGvkhwqrtU/eksnWw/xjqyMRUfHL3Fr1sdbIDxVWa5+8JZOth/nHVkcqDmyBJCIiIiIiIpWwBZJKJFXHRRY2tjzmH1seiYg0g6rjIgsbWx7zjy2PVJzYAklEREREREQqYQsklWgFGRdJxYMtj0REmqkg4yKpeLDlkdSBLZBERERERESkEiaQREREREREpBJ2YaVSQ10T61BW7LZKRKRd1DWxDmXFbqukbmyBJCIiIiIiIpWwBZJKHU6soz5seSQi0m6cWEd92PJImoItkERERERERKQStkBSqZZdixhbJQsHWxuJiEq27FrE2CpZONjaSJqMLZBERERERESkErZAEn2ArZJ5x9ZGIiIC2CqZH2xtJG3DFkgiIiIiIiJSCVsgiVTANSSzYqsjERGpgmtIZsVWR9JmbIEkIsoHIYS6i0BERKSVGEO1G1sgifLgY61uJa2Fkq2M2RNCIC0lTd3FICLSKh9rdStpLZRsZcweY6j2YwskEVEeCCEgS5chOSlZ3UUhIiLSKoyhJQMTSCKiPBBCICYyDlIdfn0SERHlBWNoycAurESFKLcun5rYvZVdVPMuPjoRAGBoaqTmkhARlSy5dfnUxO6t7KKad4yhJQPTfyKiPEh9lwoLO3NIJOouCRERkXZhDC0Z2AJJVEwKo7UvcysmWw/Vw8LOHDq6UkgY/YiIik1htPZlbsVk66F6MIaWDGyBJCLKA119HQY+IiKifGAMLRnYAkmkRdjqqH4MfERE2omtjurHGFoysAWSiIiIiIiIVMIEkoiIiIiIiFTCBJKIiIiIiIhUwgSSiIiIiIiIVMIEkoiIiIiIiFTCBJKIiIiIiIhUwgSSiIiIiIiIVMIEspgYGhvgE696qOlRHVLp+9uuo6sDG0drmNuYKba51KqApl0awtLe4qPXNbU0gY2jNaQ6xfdRmlgYw7acNXT1uIxoYTOzNkXzno1Rqa4LTCyM4dGjMap+UkndxSIiUivGUFIFYyhR8VDrt9f8+fOxa9cu3L17F0ZGRmjWrBkWLFiAatWqKY4JCQnB5MmTcfbsWSQnJ6NDhw5Yvnw5ypQpk+N1Z8+ejTlz5ihtq1atGu7evav42dPTE6dOnVI65ssvv8Tq1asVPz99+hSjR4/GiRMnYGpqiiFDhmD+/PnQ1c37bfvp5BzFl9iGuX/i2B+n0N+vBzoMaw0dXR0AwOsX0Yh8+ho13Ksqzutt9zniouKzXK9Vv2boM6krqjfOWBQ3LTUN+345gi3f70LMq7g8l08VHb9oi0Ez+sC+gq1i280zd3Bwzd+o06oGDE0McXDN37h+onAWu9fV08UA/x6oVM8Vdy7cw5+L9sNnZm/0m9wdega6CL31DNM6zkNiTCJm756KBu1qQyYTOLXtPBYOXVEoZShMLfs0Rat+Hoh6GY3N3+9CTGSs0n4DI30E3lum9IeQ3E9frMLh34NUep+Gn9ZBh8/bIjEuCdsW7EHYo4hCKT8RaRbGUMbQ3DCGvscYSlS41NoCeerUKYwZMwYXLlzAsWPHkJqaivbt2yMxMREAkJiYiPbt20MikSAoKAjnzp1DSkoKunbtCplMluu1a9asibCwMMXr7NmzWY4ZMWKE0jELFy5U7EtPT0fnzp2RkpKC8+fPY/369QgMDMQ333yT53oaGZuiSsOK6NSpE549e4YG7erg1+uLUKdDNXz73bfo2LEj+vTpg+17t6Ji/QpIS0uDp6cnYmJiMOibPlmuN/TbAZi+ZQJCox/Cx8cHnTp1wsIfF6KlTxMsvzgf1g6WimOlUinMrE2zLZeBkT5MLIyz3SfVkSp9Cfcc1wkTf/0Sh08eRP/+/dGxY0eMGTMGaabv4PfHWNT8tAqs3Uzhv3FclmsZmxvD2Pz9+5hZm0JPP+sfEBKJBBa25oonwe7dPsGgb/og3jAKIxYMRl3PmvCe1gvbd27D2HFjYe1sgV7jO6FV/2b4xKsuJk+ZjCVLF+PTz1rBsZJDxntZmcLI1DDbOkokEphZm0IikWS7PzMzK9Ns75WxmZHij5cPGRjpw9jMSHH+zO3/g145gZY+TdBnUhelY6VSKep61oS5jRlatGiBW7cy/oDo2LEjgoOD0cirXo71ULqOjhTTt06ERVUj1OvkhiFz+ivt1zPQg6GxQY7nWtq9v//GZkawsDVX6f4QUfFjDGUMzYwxlDGUqLhIhBBC3YWQe/XqFezt7XHq1Cm0bNkSR48eRceOHfHmzRuYm5sDAGJjY2FlZYWjR4+iXbt22V5n9uzZ2LNnD65fv57je3l6eqJevXpYunRptvsPHTqELl264OXLl4ontatXr4afnx9evXoFfX39j9YnLi4OFhYWSE5+h8OHj2Dbtm3YtGkTAODKlSvo2LEjRo0ahW7duuHt27fYunUrGjdujKFDh2LJkiV48+YN5s6dix5WQ5AYmwQAqPpJJay89AOmTp2KQ4cOYd68eXBycsIff/yBHTt24OLFi7Ayt0b8mwTYO71/ypn8NgWbv9+JLd/vRuX6rhj2nTcadagHAHgTGYvAmVuRnpaOEQsGwcLWXHFeYlwSNn67A97+PfHHlvVYu3YtFi1aBHt7e/zzzz+wsrJC9+7dsW7dOpw7dw6///57jvfj1fMoSHWksClrBQC4FnQLK3zXIjz0FXxm9Eaf/3WFvoEeAODU9vNo1a8ZkpKSYGNjg7dv3yquM3ToUOzduxfz5s2DT79BePLfc7xKC0OfPn1QtWpVXLx4EZcOXUNdz5owMMr4nCKfvsbv0zfj1bMo/G/daEVwlNv2414ETN+C9LR0xTaJRILuvh3Qe2IXOLjYAwCiw2Ow1n8jDE0MMGhmX8UfGleOXMeKseswaGZftBvcUunaj28+RezrONRrXQutWrXCnDlz4OnpmeN9Onr0KBo3bgxLS0s0b94c8+fPR4sWLQAAITdCsdx3HT79rBVaD/DAq2dR+H7gUngO8EDXUe1hamkCABg4cCA6d+4MHx8fJMYlYf+qo6jrWRNuTaoAAJ7de4k1fhtgaWeOLxYMhvkHfyClp6UrBfWDa//GirG/IzU5Ncdylxa7olcCAOLi4lHeuTJiY2MV309E6sQYyhjKGMoYqukYQ0sGjeqAHxub0R3B2toaAJCcnAyJRAIDg/dPewwNDSGVSnH27Nkcgx8APHjwAI6OjjA0NIS7uzvmz5+PChUqKB2zadMmbNy4EQ4ODujatStmzpwJY+OMJ2TBwcGoXbu2UjcfLy8vjB49Gv/99x/q16+vUp2qV68OfX0D/PrrrxgzZgyS4t/C2MwIX3/9NcaPH48ZM2bg+KYzMDAywC+//IKUlBQAGV9e9evXx6xZs+De7RP8veE0AODTz1rh6dOnWLp0Ke7fvw8DmREeXnuMJUuWIDw8HD/++COWLFmCa//+g2Onj+Dly5cIDg6Gh4cHJsyegOqNqsC92ye4fv06Ro0ahejoaHTq1AkTVo+ERCLBwYMHkZaWhps3b+Lq1ato3bo1xiwYA6lUiqNHj2LkyJGK+16nTh0AQHR0NLZs2YKXL19i/PjxqFu3LgYOHIhvvvkGnTt3xurVq9G1a1f0798fGzZswP79+2Fra4vx48fjt39/woN/HqNCLUesWLkcp0+fhqurK/z8/AAAK1euREpKCsaPHw8AWLx4MQBgwIABCAwMxFdffYU6rWpg8OD5GDhwIK5cuQIA+MSrLhYtWoRLly5BX18fXbt2hd8fYyGRSPDvv//irzX7kZaWhmPHjqF+/frw8/ODubUpFo943/1q6LcD0N+vOzZt2oR9k/dBKpViwIABmBroCyEEAgICcPToUdjY2GD8+PEIvL8cALBgwQK0bNkSAQEBiI+Px6hRo9CqdSscOXIEDx8+xPLly7F792588cUXePPmDV6+fIkXL17g9OnT+PXXX3H9+nXUrFkTlpaWADK6gY0cORJJSUkYOXIklp75FgCwZMkS9OjRA73Gd4bXsNZYu3YtGjdujLdv3+Lq1auIiorCpUuX0LdvXwzw64ELFy5g+PAfkJycjP79+2Punox7/NdffyEtLQ3Xr1/H1atX8eeff+Kvv/7C9u3b8e7dO9SuXRvffvstzu25jEsH/1Hp956Iih9jKGMoYyhjKFFx0JhJdGQyGSZMmAAPDw/UqlULANC0aVOYmJjAz88PSUlJSExMxOTJk5Geno6wsLAcr9WkSRMEBgbi8OHDWLVqFR4/fowWLVogPv79OIiBAwdi48aNOHHiBKZNm4YNGzZg0KBBiv3h4eFZxojIfw4PD8/2fZOTkxEXF6f0at68OVJTU3Hy5El4eHggPS0dsbGxOH78OAYOHIj9q4/ih8HLMKfPIoxz/xob5+zAD4OXoUyZMjAzM8PNmzdRu4Wb4j3qt6mN/fv3o2nTpnBxccH3A5dibt+fcPPMHQwYMAB79+4FAPz3338YNWoUjIyM8M033+Dvv/9WBNK7d++iW7du6NixI6ZNm4bNmzdjxYqM8Q4XL17El19+CWdnZ0yZMgWrV6/Gnj17AAANGjTAzz//jPXr1+PRo0eKMpmYmKBp06aoVKkSBg0ahJYtWyI1NRWLFy/G6tWrMW7cODRp0gTffPMN9uzZg+nTp6NTp07o0KEDXke9RvXGleHj44PQ0FDMnTsXNWrUQJs2bZCSkoJ27dpBV1cXgwYNwqBBgxRdQapWrQo9PT38999/iI2NxdmzZ9GhQwdFmYQQMDU1xezZs+Hr64slS5Yo7s2jR48wceJEREVFYfbs2bh9+zbGjh2LjsPbwqmaIwDAwcUeA7/uhW+++Qa///47/ve//8Hf318xdueHH35QbG/UqBGaN2+OV69eAcj4o8rPzw8+Pj7o1asXevbsiZiYGNSuXRv29vb49NNPMWjQIJQvXx7//vsvRo0aBT09PXz99dcwNTXF5s2b8fr1a0VdFixYgMGDB2PgwIHo168fbt++DQDYvn07wsPDYfL/T0wPHDiAR48eoWLFinBxcYGHhwcGDRqEqlWr4saNG+jevTt69OiBkSNHYtKkSdi5cyeAjD/0Ro4cCScnJ0ybNg137tyBn58fJk6ciAULFsDNLeP3T99Ao543EVEmjKGMoYyhjKFExUVjEsgxY8bg1q1b2Lp1q2KbnZ0d/vzzT+zfvx+mpqawsLBATEwMGjRooDQL24c6duyIvn37ok6dOvDy8sLBgwcRExOD7du3K44ZOXIkvLy8ULt2bfj4+OCPP/7A7t27ERISku86zJ8/HxYWFoqXk5MTypcvj/DwcOjq6sLCwgJxUQmIioqCTCZDmTJl8Pz+S8X5dy4+wJb5u3HrbMZEBRUqVEBISAhsy9kojjG1MkFERIQiED+/n/FHwIuHYXBwcEBExPvB3nXr1oWvry9qVK+Bn3/+GWvXrgWQ8URy+PDhaNGiBSpUqICvv/4aGzZsUJzXtWtXDBo0CO7u7hgyZAjOnz8PAJg+fTrGjRuH33//HTVr1kSdOnXwzz//wMDAAK6urrCzs0OjRo1QuXLGpATp6elYtmwZ3N3d4eLigqVLl2LRokVwdnZG8+bN8emnn2Lfvn149OgRgoOD8c0336BcuXLo1asXrK2tcfnyZVSrVg1SqRSNGjWCQZKJ0uc+dOhQrF+/Htu3b0evXr2gp6en2Kejo4PPP/8c0dHRCAsLQ+PGjXHo0CHF/vLly2P69OmoXs0NK1euRGBgINLS0lC7ZY2Me+dZA+np6ViyZAk2bNiAcpZOeH0zDt26dQMA/Prrr/j5559Ro2pNDB06FK1bt1b63Z02bRpatWqFvn37onr16vjvv//g6OgIc3NzVK9eHY6W5WFlldENyd3dHePGjUOl8lVgapp1rM3YsWPRokULdOrUCcOHD8f69etz/T20s7ODjY0NKlWqhEpOVWBvb49169Zh1KhR6Nq1Kxp/0gSzZ89WmuyiU6dO+Pzzz+Hu7o63b99CIpFAX18fVapUwcCBAwEA/xwvnIkdiKjwMYYyhjKGMoYSFReNSCB9fX1x4MABnDhxAuXLl1fa1759e4SEhCAyMhKvX7/Ghg0b8OLFC1SsWFHl61taWqJq1ap4+PBhjsc0adIEABTHfBhIACh+dnBQ7vsvN23aNMTGxipez549g0QiQeZhpnGv42BnZwddXV28fPkSrrXfdwn6xKseRv44GGVc7BTbhBBKA7DjXsejXLlyePkyI2i61HICADjXcMKLFy9Qrlw5xbEuLi4AgPWztsHFxQURERFIS0vDo0ePsGfPHgwePBifffYZfvzxR8UTMgAoW7YsXj2Pwv2rj2BqaoqkpIyxIzdP3cHQQcNw6tQpREdHw9PTEyNGjMhyH1b/L+PL2djYGHZ2dnh27yUiIiKQnJyM8ePH47PPPsNnn32W8eTPxASPHj3Cu3fvMGTIEMU+CwsLfDg899C640o/9+vXDzt27MC6deswdOhQpX0vXrxAnTp1sGXLFty/fx9v3rxBVFSUYr+zszMkEgnWf7MV1tbWMDQ0xOvXrxXjMWzKWSMqKgpCCDg5OWHbwr34cdhK/DhsJYQQePHiBVxdXbF1wW7ERcWjYsWKePHihdI9DN6X0RUo8z2Uu3PhAR5ee6z4nNJS0zCr50Jkx8XFBaf/DMa9yw/h4uKi9D4AIJVm/H5kN5xZPkvd8+fP4erqitvB93F6ezBcXV0Vv0Py94h89hpz+ixC06ZNMW7cOIwcORLlypXD9OnTIYRAk84Nsi0fEakXY2gGxlDG0OwwhhIVPrW2pwshMHbsWOzevRsnT56Eq6trjsfa2mYMZg8KCkJkZKTiKZYqEhISEBISgsGDB+d4jHyygLJlywLIeKI1b948REZGwt4+Y/D3sWPHYG5ujho1amR7DQMDA6WxJkDGl7CDgwNSU1MRFxeHFw/C4da0Kry8vPD7779j/vz5sHawgqGxAeq0qoGEhAS0H+IJ4P0XVuSNaMX1rh67gW7e3TB27FjcvXsX3+yYjCf/PYNbkyrw7z4ZPXv2VBwrfxI8fL4P7t69i7Jly0JXVxcVK1ZEo0aNMHv27Gzr8WHAlmvQrg7iohPw9O4LVKheDn379sW2bdsAZDytTE/PGDw/6qchiI+PVzzpjA57g+oulWFqaorVq1fDyclJ6bohISHQ09PDrl27sty/5ORkpKenQwiBCb9+qbTPwsICLVu2xIMHD1C7dm2loLB//360bt0aq1atAgB8++23uHHjhtJ7CiEwYsFgREZGIiUlBXZ2dogKewMAePUsCra2ttDV1cXjx48xaGYfNO3SEC16NwUAODk54f79+xg0sy8MjPTx4MEDtG7d+qP3UH6f2g32zNhwLmP2OJlMADnMZxUSEoJRo0YBAH7fsUZx/0xNTREXFwev7l4AgGfPnmV5n4p1nAFkPIl/8OABhg4diqqfVMSmzZuUPgepVApZugzmNmaQSCTw9fWFr68vIiIi0LRpU3Tp0gWftK+LE1uyzsRIROrBGMoYKi8nYyhjKFFxUmsCOWbMGGzevBl79+6FmZmZYlyEhYUFjIwypm4OCAiAm5sb7OzsEBwcjPHjx2PixIlK61y1bdsWPXv2hK+vLwBg8uTJ6Nq1K5ydnfHy5UvMmjULOjo68Pb2BpDxZbJ582Z06tQJNjY2+PfffzFx4kS0bNlSMai9ffv2qFGjBgYPHoyFCxciPDwcM2bMwJgxY7J8Qefm3Llz0NfXR8uWLREcHIy2A1ojPS0VCxYsQNu2bREXF4fu3bsj6U0Svh8wFx07dsSQIUMQFRWF6Oho1KtXDyluiWjeK2PWKqlUFybm1pg1axY6deqEmTNnwsnJCUOG/Ig7d+5g3bp1ive+ffu2YvaxmTNn4quvvgIAfPXVV2jdujXs7e3RqFEjPH/+HK9fv1Z6Empbzgo2ZS3w98X3dRk/fjwcHR3RqFEj/HP3Mn744Qf07t0bAODm5oa5c+di8+bNqFixImrWrKk4r1qTCjAwMMC4cePQr18/zJo1C5aWlrh06RJatmyJevXqoVWrVvD29sb48eMhlUpx8uRJjB49Gra2tihfvjwWL14MFxcXpeAOAIGBgdned1dXVyxZsgSnT5/GixcvEBgYqDRpw6tXrzBt2jR07doVCxcuxMiRI6Gjo4MRP/bB0O97QqqjA6lUCj8/P3h7e+Pbb7+Fvq0+tm3bhv79+2Ps2LEYO3YsFi5ciFu3buH8+fNYs2aNUhkadaqTpVxubm4ICAhAdHQ0PDw8FNv19HWxMMgv27qsWLECFSpUQHx8PAIDAxXT6bdo0QKLFi2CoaEh/v77b4SGhiq9z7Zt22BoaIiGDRviyy+/RKtWrVCrVi1YWFhg9uzZijE7cvYVbDB2xTCcOXMGt2/fxieffILw8HCkpKTA0dERZRvYwb179n/4aQshBBLeJCI5KQXWZS2LdfFwosLGGMoYyhiagTG0eDCGkpxaE0j5k60Pp2MOCAhQdKe4d+8epk2bhujoaLi4uGD69OmYOHGi0vEhISFKA6afP38Ob29vREVFwc7ODs2bN8eFCxdgZ5fRrUVfXx9///03li5disTERDg5OaF3796YMWOG4ho6Ojo4cOAARo8eDXd3d5iYmGDIkCGYO3dunur433//ITUlBSNGjMDmzZvh5eWFtwkxcHNzw+3bt7Fp0yb88ccfMDY2Rq9evRTBZOvWrRg6dCh0dHSQlpqsuJ5MlobktwmYPn062rVrhw0bNuD48eNo3rw5Vq5cCSMjQ8jS0wAAvXv3hpWVFdasWYMBAwZg5MiRSE15h+rVq+Ps2bMICAjAmTNnUK5cxpNQAGjVqpXiyZ+AwCeffKJ4yjZ06FDs27cP69atg5mZGb766it4e3tDJktHkyZNsGLFCly9ehVSqVQxKxsAyNLTkfwuEXPmzEGjRo3w559/IiUlBXXq1FHM6rd582Zs2bIFa9euhZ6eHho1aqSY1vnIkSPYs2cPbty4gR49eqBbt25wcHBAenoqkt8mQiKRQFffEJUqVcLnn38OIOOPl2nTpmHt2rVwdXXFpk2blIJDq1atULNmTfz666/w9PTE2LFjkZKcBCFLh45UIC09HUmJ8RljPKpXx8aNG6Gnp4c+fTLWFJswYQIcHR0REBCAsmXL4sKFC4rxGF9++SXKlCkD8f/rrPn4+ChaBubPn4/Nmzfj1q1bqF27Nho1apTRTUq8f3o6cuRIxficoUOHonbt2ti2bRuSkpKwf/9+VKlSBWmpyfD394eBgQHWrVuHLl26YMWKFYo/CidNmoSyZcvi9u3bcHFxQePGjXH48GGsW7cOMpkM69atQ5s2bQBk/P/T1dXN+MyFDBUqVMDRo0dx6tQpWFtbY/fu3XB2dkZi3PvuS9pICIG0lDS8jX8HKwY+KgEYQxlDGUMZQ4sLYyhlplHrQJY0sbGxsLS0xMvnT1CmbHm0bt0aGzduhJWlOeJj38DUzALGpmbQ0cnI41NSkiGEDDo6evDw8MBff/0FIwM9xLx5neXaBoZGMDWzhKFRxpTp6WlpSEyIQ0J8DGztHbH+jw24ePGiYtB/eloa4uNjkBgfC11dPZhZWMHY5P0ix+/eJiEtLRUGhhlPreNjoyGTyWBhaQuJRILk5LeQSqUwMDSCVJqxtlFqagoS4+OQmBALQyMTmJpZQE9PHxKpFBKJBOlpaUhJeYfo1xnjXoyMTWFqZgF9g4zFfGXp6UhKSkB8bDSMTcxgYmoB3f8fxJ+WloqkxHi8TUyAmYUV9A0MIZVmPNFMT0+HTJaOuDdRePcuY1yEnp4+LK3toKOji6SkBKSlpsDcwho6uu+fkaSnp0NHRwd79uxBQECAYkY5WXo6EuJjER+X0fVGCAGZEEhLTYOZhSUsLa2hp5/xxDw1JQVxsdGQSqUwNbeEnl7GGllvkxIQ++Y1TM2tYGRkgrS0VLyJjoSxiRmMTcwgS09H7JvXMDQ2gaGhCXR0dRXdk9JSUxEf9wZJifGwsLJVnC+TpcPQyBgSyfsv6eR3bxH75jVS/79+JmYWSpMipKQkIzb6FQwMjWBobApdXT3I0tOQlJgAfQNDxe9LSvK7/6+HDswtrCAAxMVEIzU1GRaWNjA0MlGMG0p+9xZxMVFISXn/R5i2yQjsAokxSTA0MYCuvm6BF3eOj4+HW636iImJgYWFRSGVlIjkGEMZQxlDNQNjKH2IcwoXIfmU5+UruOLWrVs4deoUgIwnaF9//bXiOENDQ6SmpiI9PR3du3fHnj17cPFiRr+X7CYiyEwqlUJfXx/v3r1TbDt//jysra0VkykYGBgo1sbKTCKRwMjICG/fvs12rEFOjIyMkJycDNn/Px3MKz09PUilUiQnZ/0yNTAwgEwmQ2pq4Sy2a2BgoPQ+e/fuhbm5OZydM8Y1ZJ5M4WPXya5c8ntb1M9hpFIppFIp0tLSsi1bdvcyO/Ip1LO7zoeMjY3z/LtRGsXHxzP4ERUBxtDsMYbmHWOo5mIM1U5sgSxCMpkML1++hJlZxqBqVb94dHR0Mp4+/v/A97zS19eHoWHGE8rU1FS8ffs2yzFxcXFwcnLCs2fPFN1cSjJ5faOiohSLbKelpWWZ2a0kKE2frTrrKoRAfHw8HB0dc10SgYjyhzFUczCGlkyMoZRfbIEsQlKpNMuU6sVNT09PaW2nD5mbm5f4L8jMdDN1x9HV1S3RdS9Nn6266sqnpkRFhzFU8zCGlkyMoZRXTPmJiIiIiIhIJUwgiYiIiIiISCVMIEspAwMDzJo1K0/rcWmz0lRf1pWIqGiVtu+e0lRf1pXo4ziJDhEREREREamELZBERERERESkEiaQREREREREpBImkERERERERKQSJpBERERERESkEiaQJRznSCIiIsofxlAioqyYQJZQx44dQ1JSEiQSibqLUuTS0tLUXYRic/jwYYSGhqq7GMUiKSlJ3UUgolKKMbRkYgwlKhxMIEuYR48eoW3btvDy8sL58+fVXZwiFRoaigEDBuDLL7/EnDlzEB0dre4iFRn559qpUyfcunVL3cUpUqGhoejZsyd8fHwwduxY3L59W91FIqJSgjG0ZGIMJSpcTCBLEF9fX1SvXh329vaIjIxEu3bt1F2kIhMUFISGDRsiPT0dNjY2WLx4MQYPHozg4GAAgEwmU3MJC8+Hn2uXLl3UXaQic/nyZTRt2hQGBgZo3rw5Dh48iM8++wyHDh0CULI+VyLSLIyhjKHajjGUio0grZeeni7WrFkjJBKJ2LZtm2L748ePRXJyshpLVnS+/PJLMXDgQMXPFy5cEF26dBHNmjVTY6kK36FDh4REIhG//fabYtudO3dEdHS0GktVdGbOnCm8vLxEamqqEEKIBw8eiMGDB4ty5cqJ9PR0NZeOiEoixlDG0JKCMZSKC1sgSwCpVIpmzZqhdevW2L9/P+7fv482bdqgZ8+eqFmzJubOnYsnT54A0P6nT+L/JzR48uQJDA0NFdubNGmC0aNH4/nz51iwYAEA7a8rALi7u6N79+7Yvn07bty4gZYtW6Jfv36oVasWxowZg6tXrwIoGXUFMroZSSQS6OrqAgAqV64MPz8/SCQSTJkyBUDJqSsRaQbGUMbQklBXgDGUig8TSC30+vVrHDp0CDdu3EBycjIAoFq1ahgxYgS2bdsGDw8PNGvWDNOnT4ePjw8CAwMxd+5cJCYmQirVro88c11TUlIgkUiQkpICExMTyGQypTEbHh4e8Pb2xrp16xATE6N1dY2JiVEM7pdPamBhYQE/Pz+cOnUKbdq0QatWrfDTTz/Bz88P//zzD6ZMmaL1dU1PTweQEdTKli2L9PR0xR9rAFC9enVMnToVq1atwuvXr7WurkSkWRhDGUMZQ4kKSN1NoJQ3M2fOFJaWlqJZs2ZCT09PjBs3ToSEhAghhHjy5In47rvvxIYNG5TOWbJkiahXr57Yt2+fOoqcb9nV9eHDh0KIjDqVL19eBAcHK51z8OBBUa9ePbF161Z1FDnffvzxR2FmZib69++v2CbvbpKUlCRWrVolVq9erdQFZceOHaJu3bpi1apVxV7egsiurmlpaUIIIbZs2SJq1KghNm/erHTOzZs3Rd26dcWiRYuKtaxEVLIwhjKGyjGGEuUfH0NoiaioKHz++ec4ePAgduzYgb/++gvLli3DpUuXsGfPHgBAhQoVMHToUPTr1w/A+24KQ4YMwYMHD9RV9DxTpa4TJkwAAKxZswavXr1SnNu8eXO8fPkSBgYGaih53iUnJ2Py5MnYtm0bWrRogRcvXmDHjh1KxxgZGWHAgAEYOnQopFKpogtSx44dERUVpTXrlOVWV3kdBgwYABsbG+zcuRN37txRnFupUiXIZDLo6+urpexEpN0YQxlDGUMZQ6nwMIHUcAkJCQCA58+fIy0tDd9++y3atm0LS0tLjBo1Cjo6OoiJiVEcX65cOcUXhLybwj///AMzMzPY2NgUe/nzQpW6xsbGKo7/+eefsXfvXmzdulWxLTo6GiYmJhof/BISEiCEgIGBASpWrIjhw4djwYIFsLW1xebNmxVdauR/wFhaWirqJF+X7N69e5BIJHBxcVFXNVSiSl11dXWRkpICAPjmm29w584d/Prrr4prJCcnIyUlBVZWVuqqBhFpIcZQxlCAMZQxlAqdupo+KXdxcXFi0KBBokuXLkIIIaKjo8WFCxcU++XdFXr16iWmTZuW5fz09HQhk8nErVu3RNu2bcWAAQM0dja5gtTV19dX1K1bV3Tp0kVs3bpVeHp6iqZNm4rXr18XXwXyQF7Xrl27KralpKQo/r1u3TrRpEkTsWTJkmzPT09PF+/evRO3bt0S7dq1E127dhWxsbFFXex8yWtdZTKZYt+PP/4oatasKZo0aSKWL18u2rRpI2rXri2ePHlSbOUnIu3FGMoYmh3GUMZQKhxMIDXQrFmzhIGBgbCyshJ2dnYiPDxcab+8D/+7d++Eg4OD2LVrlxDi/ZfH27dvxQ8//CAGDhwojIyMxLBhw0RSUlLxVkJF+a2r/Es0Pj5e/PXXX8LLy0s0bdpUfPbZZyIhIaF4K6GiD+saEREhhFD+0o+NjRXDhg0Tbdq0EXfu3BFCKN+DFStWiAEDBggTExMxdOhQkZiYWPwVUUF+6yr/XFNSUsS1a9eEj4+PaNeunRg2bJjGfq5EpFkYQ99jDGUMZQylosAEUoNs27ZNlClTRlStWlWcOHFC7N27V1SpUkXcvHkz2+MvX74snJycxIsXL7Ls2759u5g0aZK4detWURc7XwqzrkIIkZqaKuLi4oqyyPmmal3lgeHgwYOiefPmYsqUKYp98jWdjh49KubOnav1n2tudZU/LZfT1D/ciEizMIYyhgrBGMoYSsWBCaSGCA8PF126dBHz589XbHv+/LmQSCTi9OnTQgiRZRHYwMBA0bp1a8XPp06dEsuXLy+eAhdAYdV15cqVxVPgAshPXYUQYsqUKaJ58+bi2LFjYseOHeLzzz8vtjLnV2HV9Ysvvii2MhNRycAYyhiaGWMoUdHiJDoawt7eHrt374a/vz+A9zNq1atXD6dOnQKALGv37N27F61atcKrV6/QtWtXtG7dWrGmldDgWcUKq65v374t3oLnQ17rKh/wP3DgQKSkpKBbt27w9vaGqamp0vmaqLDqamxsXMwlJyJtxxjKGAowhjKGUnFhAqkhJBIJdHV1lX62s7ODTCZDUlISgPdfFgAQERGBS5cuYf/+/XBycoIQAuHh4fjf//6nOF9TFXZdNVle6yqVSvHy5Uv89ttvuHz5Mvr374+wsDD8/PPPivM1VWHXlYhIVYyhjKEAYyhjKBUX3Y8fQoXp7NmzKF++PFxcXCCEyPHLTL5eT4MGDXD69GkAyk+eIiMjkZiYCD09PZw4cQLu7u7FUv68YF2z+lhdAeDAgQMICgrCuXPnWFciokwYV7JiXbUrrpSmulLJxRbIYvLkyRP06NEDLVu2xMKFCwHk/iRMvtits7MzkpOT8eLFCwDvuzS4urpi//79CA4O1rgvDdY173UF3td35MiRuHv3LutKRPT/GFdYV0C740ppqiuVfEwgi8G4ceNQsWJF6OjooE2bNkhPT1eMs8iJ/KlU+fLl8eLFC5iZmQF4/2VjamqK5s2bF3nZ84p1zV9dgff11cQxGqWprkSkWRhXWFc5bY0rpamuVDowgSxCly5dgqGhIc6fP49z585h586dcHNzw9WrV2FgYJDrf3z5l0Pz5s0RERGBy5cvF1ex84V1Lby6atIYjdJUVyLSLIwrrOuHtC2ulKa6UunCBLKQZf4y0NXVxZ49e3DlyhU0bdoUANCoUSO8fPkSz58/V+k/flRUFPr16wdXV9ciK3N+sa6sq7bXlYg0S2n6/mFdWVdtryuVXpxEpxAlJCQgJSUF1tbWADKmXpYPeJZ3RdDT04OBgQFiYmJQvnx5pfOTkpJw+PBh9OrVS3F8s2bN0KxZs2Kvy8ewrqyrtteViDRLafr+YV1ZV22vK5VubIEsJDNmzEDdunXRo0cPDBgwAPfv31f60pDz9PTEixcvEBERAUB5SuZz586hT58++PvvvzW6WwLryrpqe12JSLOUpu8f1pV11fa6EjGBLKCUlBQMHjwYBw8exK+//oovvvgC8fHx6NChA65evQogo4965gHPdevWxdmzZwEoT8ncuHFjfPvtt6hRo0bxV0QFrCvrCmh3XYlIs5Sm7x/WlXUFtLuuRAqCCuTmzZuiZs2a4sSJE4ptb9++Febm5qJ///7iwYMHQggh0tPThRBCpKWlidq1a4tp06YpbdcGrCvrKoR215WINEtp+v5hXVlXIbS7rkRybIEsoNjYWNy7dw9169ZVbIuIiIC1tTXOnj2Lv//+G0IISKVSpKWlQUdHBx4eHggKCgKQdVFYTca6sq7aXlci0iyl6fuHdWVdtb2uRHL8rS0gc3Nz1K5dGzNmzFBs+/XXX9GhQwdUqFABe/bsgRACQgjo6mbMWST/EpH3f9cWrCvrqu11JSLNUpq+f1hX1lXb60qkUHyNnSXT27dvRUBAgNDT0xNNmjQRNjY2wtHRUYSGhoqgoCChq6sr4uPjhRDvuymcPn1a3Lt3T53FzhfWlXXV9roSkWYpTd8/rCvrqu11JZLjMh75lJaWBl1dXRgaGmLo0KGoWbMmrl27BisrK/Tt2xcAcPnyZVSuXBlv3ryBqampoptCixYt1Fn0PGNdWVdtrysRaZbS9P3DurKu2l5Xog8xgcwj+ReGrq4uUlNT4e/vj9GjR6NRo0Zo1KiR0rFnzpxB1apV4eTkpKbSFgzryrpqe12JSLOUpu8f1pV11fa6EuWEYyBVlJ6ertR/fenSpbC1tcXevXuV1up59OgRHj16hKlTp2LHjh0YNmwYAOU1gDQd68q6antdiUizlKbvH9aVddX2uhJ9VPH3mtU+aWlpin///fffolKlSqJMmTJi7dq1IjU1VenYTZs2iVq1aonatWuLs2fPFndRC4x1ZV21va5EpFlK0/cP68q6antdiVTBBFJFT58+FR06dBB6enpi8uTJIioqSmm/TCYTQgiRmJgozp8/r44iFhrW9T3WlYio4ErT9w/r+h7rSlQyMYFUwZ9//il0dXVF586dxZ07d9RdnCLFupZMpamuRKRZStP3D+taMpWmuhKpQiIEO2V/zKNHjxAREQF3d3d1F6XIsa4lU2mqKxFpltL0/cO6lkylqa5EqmACSURERERERCrhLKxERERERESkEiaQREREREREpBImkERERERERKQSJpBERERERESkEiaQREREREREpBImkERERERERKQSJpBERERERESkEiaQREREREREpBImkERERERERKQSJpBERERERESkEiaQRIUgNDQUEokE169fL5LrSyQS7Nmzp0iuTUREpE6MoUTahQkklQhDhw5Fjx491Pb+Tk5OCAsLQ61atQAAJ0+ehEQiQUxMjNrKREREpArGUCLKC111F4CoJNDR0YGDg4O6i0FERKR1GEOJtAtbIKnEO3XqFBo3bgwDAwOULVsW/v7+SEtLU+z39PTEuHHjMHXqVFhbW8PBwQGzZ89Wusbdu3fRvHlzGBoaokaNGvj777+VusRk7n4TGhqK1q1bAwCsrKwgkUgwdOhQAICLiwuWLl2qdO169eopvd+DBw/QsmVLxXsdO3YsS52ePXuGfv36wdLSEtbW1ujevTtCQ0MLequIiIiUMIYS0YeYQFKJ9uLFC3Tq1AmNGjXCjRs3sGrVKqxbtw7fffed0nHr16+HiYkJLl68iIULF2Lu3LmKoJOeno4ePXrA2NgYFy9exG+//Ybp06fn+J5OTk7YuXMnAODevXsICwvDzz//rFJ5ZTIZevXqBX19fVy8eBGrV6+Gn5+f0jGpqanw8vKCmZkZzpw5g3PnzsHU1BQdOnRASkpKXm4PERFRjhhDiSg77MJKJdovv/wCJycnrFixAhKJBNWrV8fLly/h5+eHb775BlJpxjOUOnXqYNasWQCAKlWqYMWKFTh+/Dg+/fRTHDt2DCEhITh58qSii828efPw6aefZvueOjo6sLa2BgDY29vD0tJS5fL+/fffuHv3Lo4cOQJHR0cAwPfff4+OHTsqjtm2bRtkMhnWrl0LiUQCAAgICIClpSVOnjyJ9u3b5+0mERERZYMxlIiywwSSSrQ7d+7A3d1dESQAwMPDAwkJCXj+/DkqVKgAICP4ZVa2bFlERkYCyHgC6uTkpDQ+o3HjxkVWXicnJ0XgAwB3d3elY27cuIGHDx/CzMxMafu7d+8QEhJSJOUiIqLShzGUiLLDBJIIgJ6entLPEokEMpms0N9HKpVCCKG0LTU1NU/XSEhIQMOGDbFp06Ys++zs7ApUPiIiorxiDCUqXZhAUonm5uaGnTt3QgiheIJ67tw5mJmZoXz58ipdo1q1anj27BkiIiJQpkwZAMDly5dzPUdfXx9AxtiPzOzs7BAWFqb4OS4uDo8fP1Yq77NnzxAWFoayZcsCAC5cuKB0jQYNGmDbtm2wt7eHubm5SnUgIiLKK8ZQIsoOJ9GhEiM2NhbXr19Xeo0cORLPnj3D2LFjcffuXezduxezZs3CpEmTFGM3PubTTz9FpUqVMGTIEPz77784d+4cZsyYAQBK3Xoyc3Z2hkQiwYEDB/Dq1SskJCQAANq0aYMNGzbgzJkzuHnzJoYMGQIdHR3Fee3atUPVqlUxZMgQ3LhxA2fOnMky2YCPjw9sbW3RvXt3nDlzBo8fP8bJkycxbtw4PH/+PD+3joiISjnGUMZQIlUxgaQS4+TJk6hfv77S69tvv8XBgwdx6dIl1K1bF6NGjcLw4cMVwUsVOjo62LNnDxISEtCoUSN88cUXioBkaGiY7TnlypXDnDlz4O/vjzJlysDX1xcAMG3aNLRq1QpdunRB586d0aNHD1SqVElxnlQqxe7du/H27Vs0btwYX3zxBebNm6d0bWNjY5w+fRoVKlRAr1694ObmhuHDh+Pdu3d8mkpERPnCGMoYSqQqifiwMzkRfdS5c+fQvHlzPHz4UCl4ERERUe4YQ4m0GxNIIhXs3r0bpqamqFKlCh4+fIjx48fDysoKZ8+eVXfRiIiINBpjKFHJwkl0iFQQHx8PPz8/PH36FLa2tmjXrh1++ukndReLiIhI4zGGEpUsbIEkIiIiIiIilXASHSIiIiIiIlIJE0giIiIiIiJSCRNIIiIiIiIiUgkTSCIiIiIiIlIJE0giIiIiIiJSCRNIIiIiIiIiUgkTSCIiIiIiIlIJE0giIiIiIiJSCRNIIiIiIiIiUsn/AVNCTELu3pQmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -462,7 +492,9 @@ ], "source": [ "for ag_map in agreement_categorical_catalog['agreement_maps'].unique():\n", - " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cat_plot(title=ag_map)" + " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cat_plot(\n", + " title=f'Agreement Map {int(ag_map.split(\"_\")[-1][0]) + 1}'\n", + " )" ] }, { @@ -483,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 7, "id": "a86f7eca", "metadata": {}, "outputs": [ @@ -511,6 +543,7 @@ " map_id\n", " compare_id\n", " agreement_maps\n", + " catalog_attribute_1\n", " \n", " \n", " \n", @@ -519,35 +552,42 @@ " ./candidate_continuous_0.tif\n", " compare1\n", " ./agreement_continuous_0.tif\n", + " 1\n", " \n", " \n", " 1\n", " ./candidate_continuous_1.tif\n", " compare2\n", " ./agreement_continuous_1.tif\n", + " 2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id agreement_maps\n", - "0 ./candidate_continuous_0.tif compare1 ./agreement_continuous_0.tif\n", - "1 ./candidate_continuous_1.tif compare2 ./agreement_continuous_1.tif" + " map_id compare_id agreement_maps \\\n", + "0 ./candidate_continuous_0.tif compare1 ./agreement_continuous_0.tif \n", + "1 ./candidate_continuous_1.tif compare2 ./agreement_continuous_1.tif \n", + "\n", + " catalog_attribute_1 \n", + "0 1 \n", + "1 2 " ] }, - "execution_count": 90, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "candidate_continuous_catalog['catalog_attribute_1'] = [1, 2]\n", "candidate_continuous_catalog" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 8, "id": "1b94b2cc", "metadata": {}, "outputs": [ @@ -574,6 +614,7 @@ " \n", " map_id\n", " compare_id\n", + " catalog_attribute_2\n", " \n", " \n", " \n", @@ -581,28 +622,31 @@ " 0\n", " ./benchmark_continuous_0.tif\n", " compare1\n", + " 3\n", " \n", " \n", " 1\n", " ./benchmark_continuous_1.tif\n", " compare2\n", + " 4\n", " \n", " \n", "\n", "" ], "text/plain": [ - " map_id compare_id\n", - "0 ./benchmark_continuous_0.tif compare1\n", - "1 ./benchmark_continuous_1.tif compare2" + " map_id compare_id catalog_attribute_2\n", + "0 ./benchmark_continuous_0.tif compare1 3\n", + "1 ./benchmark_continuous_1.tif compare2 4" ] }, - "execution_count": 91, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "benchmark_continuous_catalog['catalog_attribute_2'] = [3, 4]\n", "benchmark_continuous_catalog" ] }, @@ -616,7 +660,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 9, "id": "6dad7a6d", "metadata": {}, "outputs": [ @@ -643,6 +687,7 @@ " \n", " 0\n", " 1\n", + " 2\n", " \n", " \n", " \n", @@ -650,41 +695,61 @@ " map_id_candidate\n", " ./candidate_continuous_0.tif\n", " ./candidate_continuous_1.tif\n", + " ./candidate_continuous_1.tif\n", " \n", " \n", " compare_id\n", " compare1\n", " compare2\n", + " compare2\n", " \n", " \n", " agreement_maps\n", " ./agreement_continuous_0.tif\n", " ./agreement_continuous_1.tif\n", + " ./agreement_continuous_1.tif\n", + " \n", + " \n", + " catalog_attribute_1\n", + " 1\n", + " 2\n", + " 2\n", " \n", " \n", " map_id_benchmark\n", " ./benchmark_continuous_0.tif\n", " ./benchmark_continuous_1.tif\n", + " ./benchmark_continuous_1.tif\n", + " \n", + " \n", + " catalog_attribute_2\n", + " 3\n", + " 4\n", + " 4\n", " \n", " \n", " band\n", " 1\n", " 1\n", + " 2\n", " \n", " \n", " coefficient_of_determination\n", " -0.06616\n", - " -0.329965\n", + " -2.829421\n", + " 0.10903\n", " \n", " \n", " mean_absolute_error\n", " 0.317389\n", " 0.485031\n", + " 0.485031\n", " \n", " \n", " mean_absolute_percentage_error\n", " 0.159568\n", - " 0.177735\n", + " 0.202235\n", + " 0.153235\n", " \n", " \n", "\n", @@ -695,24 +760,40 @@ "map_id_candidate ./candidate_continuous_0.tif \n", "compare_id compare1 \n", "agreement_maps ./agreement_continuous_0.tif \n", + "catalog_attribute_1 1 \n", "map_id_benchmark ./benchmark_continuous_0.tif \n", + "catalog_attribute_2 3 \n", "band 1 \n", "coefficient_of_determination -0.06616 \n", "mean_absolute_error 0.317389 \n", "mean_absolute_percentage_error 0.159568 \n", "\n", - " 1 \n", + " 1 \\\n", + "map_id_candidate ./candidate_continuous_1.tif \n", + "compare_id compare2 \n", + "agreement_maps ./agreement_continuous_1.tif \n", + "catalog_attribute_1 2 \n", + "map_id_benchmark ./benchmark_continuous_1.tif \n", + "catalog_attribute_2 4 \n", + "band 1 \n", + "coefficient_of_determination -2.829421 \n", + "mean_absolute_error 0.485031 \n", + "mean_absolute_percentage_error 0.202235 \n", + "\n", + " 2 \n", "map_id_candidate ./candidate_continuous_1.tif \n", "compare_id compare2 \n", "agreement_maps ./agreement_continuous_1.tif \n", + "catalog_attribute_1 2 \n", "map_id_benchmark ./benchmark_continuous_1.tif \n", - "band 1 \n", - "coefficient_of_determination -0.329965 \n", + "catalog_attribute_2 4 \n", + "band 2 \n", + "coefficient_of_determination 0.10903 \n", "mean_absolute_error 0.485031 \n", - "mean_absolute_percentage_error 0.177735 " + "mean_absolute_percentage_error 0.153235 " ] }, - "execution_count": 101, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -754,13 +835,13 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 10, "id": "c97ea173", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -770,7 +851,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -781,7 +862,9 @@ ], "source": [ "for ag_map in agreement_continuous_catalog['agreement_maps'].unique():\n", - " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cont_plot(title=ag_map)" + " rxr.open_rasterio(ag_map, mask_and_scale=True).gval.cont_plot(\n", + " title=f'Agreement Map {int(ag_map.split(\"_\")[-1][0]) + 1}'\n", + " )" ] } ], diff --git a/notebooks/Subsampling Tutorial.ipynb b/notebooks/Subsampling Tutorial.ipynb index 96cab560..b66a18d1 100644 --- a/notebooks/Subsampling Tutorial.ipynb +++ b/notebooks/Subsampling Tutorial.ipynb @@ -1790,9 +1790,7 @@ "cell_type": "code", "execution_count": 25, "id": "a9e533c6", - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "data": { diff --git a/notebooks/livneh_2011_precip.tif b/notebooks/livneh_2011_precip.tif new file mode 100644 index 00000000..b7bd57f8 Binary files /dev/null and b/notebooks/livneh_2011_precip.tif differ diff --git a/notebooks/prism_2011_precip.tif b/notebooks/prism_2011_precip.tif new file mode 100644 index 00000000..823db362 Binary files /dev/null and b/notebooks/prism_2011_precip.tif differ diff --git a/pyproject.toml b/pyproject.toml index 0d7032b2..eb308926 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,7 +12,7 @@ authors = [ requires-python = ">=3.8" keywords = ["geospatial", "evaluations"] license = {text = "MIT"} -version = "0.2.4" +version = "0.2.5" dynamic = ["readme", "dependencies"] [project.optional-dependencies] diff --git a/requirements.txt b/requirements.txt index 66198d84..ff5699f7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -12,4 +12,6 @@ matplotlib==3.7.1 contextily==1.3.0 flox==0.7.2 xskillscore==0.0.24 -pyogrio==0.7.2 \ No newline at end of file +pyogrio==0.7.2 +pystac-client==0.7.5 +stackstac==0.5.0 diff --git a/src/gval/comparison/compute_continuous_metrics.py b/src/gval/comparison/compute_continuous_metrics.py index c38607ae..d3db4c17 100644 --- a/src/gval/comparison/compute_continuous_metrics.py +++ b/src/gval/comparison/compute_continuous_metrics.py @@ -17,10 +17,10 @@ from gval import ContStats from gval.utils.schemas import Metrics_df, Subsample_identifiers, Sample_identifiers -from gval.utils.loading_datasets import _check_dask_array, _convert_to_dataset +from gval.utils.loading_datasets import _convert_to_dataset -def _get_selected_datasets( +def _get_masked_data( agreement: xr.Dataset, candidate: xr.Dataset, benchmark: xr.Dataset, @@ -28,7 +28,7 @@ def _get_selected_datasets( var_name: str, ) -> List[xr.Dataset]: """ - Selects specific coordinates for integer valued datasets to not process nodata values + Gets masked data for integer valued datasets in order to not process nodata values Parameters ---------- @@ -49,51 +49,17 @@ def _get_selected_datasets( Datasets with selected coordinates """ - is_dsk = _check_dask_array(agreement) cmask, bmask = ( xr.where(candidate[var_name] == nodata, 0, 1), xr.where(benchmark[var_name] == nodata, 0, 1), ) tmask = cmask & bmask - # Create a coord meshgrid and select appropriate coords to select from xarray - if is_dsk: - with da.config.set({"array.slicing.split_large_chunks": True}): - grid_coords = da.array.asarray( - da.array.meshgrid(candidate.coords["x"], candidate.coords["y"]) - ).T.reshape(-1, 2) - picked_coords = grid_coords[da.array.ravel(tmask.data).astype(bool), :] - else: - grid_coords = np.array( - np.meshgrid(candidate.coords["x"], candidate.coords["y"]) - ).T.reshape(-1, 2) - picked_coords = grid_coords[np.ravel(tmask.data).astype(bool), :] - # Select coordinates from xarray with da.config.set({"array.slicing.split_large_chunks": True}): - agreement_sel = ( - agreement[var_name].sel( - {"x": picked_coords[:, 0], "y": picked_coords[:, 1]} - ) - if picked_coords is not None - else agreement[var_name] - ) - - candidate_sel = ( - candidate[var_name].sel( - {"x": picked_coords[:, 0], "y": picked_coords[:, 1]} - ) - if picked_coords is not None - else candidate[var_name] - ) - - benchmark_sel = ( - benchmark[var_name].sel( - {"x": picked_coords[:, 0], "y": picked_coords[:, 1]} - ) - if picked_coords is not None - else benchmark[var_name] - ) + agreement_sel = agreement[var_name].where(tmask.compute(), drop=True) + candidate_sel = candidate[var_name].where(tmask.compute(), drop=True) + benchmark_sel = benchmark[var_name].where(tmask.compute(), drop=True) return ( agreement_sel, @@ -174,7 +140,7 @@ def _compute_continuous_metrics( # Iterate through each band and gather statistics for nodata_idx, var_name in enumerate(agreement.data_vars): # Create mask for all nodata values - agreement_sel, candidate_sel, benchmark_sel = _get_selected_datasets( + agreement_sel, candidate_sel, benchmark_sel = _get_masked_data( agreement, candidate, benchmark, nodata[nodata_idx], var_name ) diff --git a/src/gval/utils/loading_datasets.py b/src/gval/utils/loading_datasets.py index 954e37ad..2c9b7934 100644 --- a/src/gval/utils/loading_datasets.py +++ b/src/gval/utils/loading_datasets.py @@ -3,9 +3,10 @@ __author__ = "Fernando Aristizabal" + +import warnings from typing import Union, Optional, Tuple, Iterable from numbers import Number - import ast import rioxarray as rxr @@ -14,6 +15,9 @@ from tempfile import NamedTemporaryFile from rio_cogeo.cogeo import cog_translate from rio_cogeo.profiles import cog_profiles +import pystac_client + +import stackstac _MEMORY_STRATEGY = "normal" @@ -136,7 +140,7 @@ def _check_dask_array(original_map: Union[xr.DataArray, xr.Dataset]) -> bool: Parameters ---------- - original_map: Union[xr.DataArray, xr.Dataset] + original_map : Union[xr.DataArray, xr.Dataset] Map to be reprojected Returns @@ -161,7 +165,7 @@ def _parse_string_attributes( Parameters ---------- - obj: Union[xr.DataArray, xr.Dataset] + obj : Union[xr.DataArray, xr.Dataset] Xarray object with possible string attributes Returns @@ -217,7 +221,12 @@ def _convert_to_dataset(xr_object=Union[xr.DataArray, xr.Dataset]) -> xr.Dataset if isinstance(xr_object, xr.DataArray): nodata = xr_object.rio.nodata - xr_object = xr_object.to_dataset(dim="band") + + xr_object = ( + xr_object.to_dataset(dim="band") + if "band" in xr_object.dims + else xr_object.to_dataset(name="1") + ) xr_object = xr_object.rename_vars({x: f"band_{x}" for x in xr_object.data_vars}) # Account for nodata @@ -229,6 +238,207 @@ def _convert_to_dataset(xr_object=Union[xr.DataArray, xr.Dataset]) -> xr.Dataset return xr_object +def _get_raster_band_nodata(band_metadata, nodata_fill) -> Number: + """ + Extracts nodata information from STAC APIs that implement Raster Extension + + Parameters + ---------- + band_metadata : list + Metadata from raster:bands extension + nodata_fill : Number + Fill in value for missing data + + Returns + ------- + Number + Number representing nodata + + Raises + ------ + ValueError + + """ + + if band_metadata: + prop_string = str(band_metadata.coords["raster:bands"].values) + idx1, idx2 = prop_string.find("{"), prop_string.rfind("}") + + return ast.literal_eval(prop_string[idx1 : idx2 + 1]).get("nodata") + else: + if nodata_fill is None: + raise ValueError( + "Must have nodata fill value if nodata is not present in metadata" + ) + + return nodata_fill + + +def _set_nodata( + stack: xr.DataArray, band_metadata: list = None, nodata_fill: Number = None +) -> Number: + """ + Sets nodata information from STAC APIs that implement Raster Extension + + Parameters + ---------- + stack : xr.DataArray + Data to set nodata attribute + band_metadata : list + Metadata from raster:bands extension + nodata_fill : Number + Fill in value for missing data + + """ + + if stack.rio.nodata is not None: + stack.rio.write_nodata(stack.rio.nodata, inplace=True) + elif stack.rio.encoded_nodata is not None: + stack.rio.write_nodata(stack.rio.encoded_nodata, inplace=True) + else: + stack.rio.write_nodata( + _get_raster_band_nodata(band_metadata, nodata_fill), inplace=True + ) + + +def _set_crs(stack: xr.DataArray, band_metadata: list = None) -> Number: + """ + + Parameters + ---------- + stack : xr.DataArray + Original data with no information + band_metadata : dict + Information with band metadata + + Returns + ------- + Xarray DataArray with proper CRS + + """ + + if stack.rio.crs is not None: + return stack.rio.write_crs(stack.rio.crs) + else: + return stack.rio.write_crs(f"EPSG:{band_metadata['epsg'].values}") + + +def get_stac_data( + url: str, + collection: str, + time: str, + bands: list = None, + query: str = None, + time_aggregate: str = None, + max_items: int = None, + intersects: dict = None, + bbox: list = None, + resolution: int = None, + nodata_fill: Number = None, +) -> xr.Dataset: + """ + + Parameters + ---------- + url : str + Address hosting the STAC API + collection : str + Name of collection to get (currently limited to one) + time : str + Single or range of values to query in the time dimension + bands: list, default = None + Bands to retrieve from service + query : str, default = None + String command to filter data + time_aggregate : str, default = None + Method to aggregate multiple time stamps + max_items : int, default = None + The maximum amount of records to retrieve + intersects : dict, default = None + Dictionary representing the type of geometry and its respective coordinates + bbox : list, default = None + Coordinates to filter the spatial range of request + resolution : int, default = 10 + Resolution to get data from + nodata_fill : Number, default = None + Value to fill nodata where not present + + Returns + ------- + xr.Dataset + Xarray object with resepective STAC API data + + """ + + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + # Call cataloging url, search, and convert to xarray + catalog = pystac_client.Client.open(url) + + stac_items = catalog.search( + datetime=time, + collections=[collection], + max_items=max_items, + intersects=intersects, + bbox=bbox, + query=query, + ).get_all_items() + + stack = stackstac.stack(stac_items, resolution=resolution) + + # Only get unique time indices in case there are duplicates + _, idxs = np.unique(stack.coords["time"], return_index=True) + stack = stack[idxs] + + # Aggregate if there is more than one time + if stack.coords["time"].shape[0] > 1: + crs = stack.rio.crs + if time_aggregate == "mean": + stack = stack.mean(dim="time") + stack.attrs["time_aggregate"] = "mean" + elif time_aggregate == "min": + stack = stack.min(dim="time") + stack.attrs["time_aggregate"] = "min" + elif time_aggregate == "max": + stack = stack.max(dim="time") + stack.attrs["time_aggregate"] = "max" + else: + raise ValueError("A valid aggregate must be used for time ranges") + + stack.rio.write_crs(crs, inplace=True) + else: + stack = stack[0] + stack.attrs["time_aggregate"] = "none" + + # Select specific bands + if bands is not None: + bands = [bands] if isinstance(bands, str) else bands + stack = stack.sel({"band": bands}) + + band_metadata = ( + stack.coords["raster:bands"] if "raster:bands" in stack.coords else None + ) + if "band" in stack.dims: + og_names = [name for name in stack.coords["band"]] + names = [f"band_{x + 1}" for x in range(len(stack.coords["band"]))] + stack = stack.assign_coords({"band": names}).to_dataset(dim="band") + + for metadata, var, og_var in zip(band_metadata, stack.data_vars, og_names): + _set_nodata(stack[var], metadata, nodata_fill) + stack[var] = _set_crs(stack[var], band_metadata) + stack[var].attrs["original_name"] = og_var + + else: + stack = stack.to_dataset(name="band_1") + _set_nodata(stack["band_1"], band_metadata, nodata_fill) + stack["band_1"] = _set_crs(stack["band_1"]) + stack["band_1"].attrs["original_name"] = ( + bands[0] if isinstance(bands, list) else bands + ) + + return stack + + def _create_circle_mask( sizes: int | Tuple[int], center: Tuple[Number, Number], radius: Number ) -> np.ndarray: diff --git a/tests/cases_stac.py b/tests/cases_stac.py new file mode 100644 index 00000000..272425fc --- /dev/null +++ b/tests/cases_stac.py @@ -0,0 +1,193 @@ +""" +Test functionality for gval/statistics modules +""" + +# __all__ = ['*'] + + +import numpy as np +import pandas as pd +from pytest_cases import parametrize + +url = "https://earth-search.aws.element84.com/v1" +collection = "sentinel-2-l2a" +bbox = [-105.78, 35.79, -105.72, 35.84] + + +bands = ["aot", ["aot"], ["aot"], ["aot"], ["aot", "rededge1"]] + + +time = [ + ["2020-04-01", "2020-04-03"], + ["2020-04-01/2020-04-03", "2020-04-06/2020-04-08"], + ["2020-04-01/2020-04-03", "2020-04-06/2020-04-08"], + ["2020-04-01/2020-04-03", "2020-04-06/2020-04-08"], + ["2020-04-01", "2020-04-03"], +] + +time_aggreagte = [None, "mean", "min", "max", None] + +nodata_fill = [None, None, None, None, 0] + +expected_df = [ + { + "band": ["1"], + "coefficient_of_determination": [-1.4498682989135663], + "mean_absolute_error": [0.025393391237534115], + "mean_absolute_percentage_error": [0.20440844788169352], + "mean_normalized_mean_absolute_error": [0.20592052600829783], + "mean_normalized_root_mean_squared_error": [0.2110757427848459], + "mean_percentage_error": [-0.20540028455073725], + "mean_signed_error": [-0.025329236900295846], + "mean_squared_error": [0.0006775147935436701], + "range_normalized_mean_absolute_error": [0.31741739046917644], + "range_normalized_root_mean_squared_error": [0.32536392930255564], + "root_mean_squared_error": [0.026029114344204452], + "symmetric_mean_absolute_percentage_error": [0.22778286629345662], + }, + { + "band": ["1"], + "coefficient_of_determination": [0.5954048574471591], + "mean_absolute_error": [0.011375152039973328], + "mean_absolute_percentage_error": [0.09299193429857326], + "mean_normalized_mean_absolute_error": [0.09198102377977661], + "mean_normalized_root_mean_squared_error": [0.0950603218421001], + "mean_percentage_error": [-0.03739148233378963], + "mean_signed_error": [-0.004624147232424582], + "mean_squared_error": [0.0001382026920448174], + "range_normalized_mean_absolute_error": [0.10036898858799995], + "range_normalized_root_mean_squared_error": [0.10372909504665788], + "root_mean_squared_error": [0.011755964105287894], + "symmetric_mean_absolute_percentage_error": [0.09373343991103603], + }, + { + "band": ["1"], + "coefficient_of_determination": [0.62257119465569], + "mean_absolute_error": [0.017518999671533943], + "mean_absolute_percentage_error": [0.19568589409159515], + "mean_normalized_mean_absolute_error": [0.15469671510079602], + "mean_normalized_root_mean_squared_error": [0.1715846316993916], + "mean_percentage_error": [0.013368590460465646], + "mean_signed_error": [0.0015139580160649765], + "mean_squared_error": [0.0003775836662784796], + "range_normalized_mean_absolute_error": [0.11450326582701924], + "range_normalized_root_mean_squared_error": [0.12700334769555513], + "root_mean_squared_error": [0.019431512197419933], + "symmetric_mean_absolute_percentage_error": [0.15366954251075923], + }, + { + "band": ["1"], + "coefficient_of_determination": [-0.41271964773267755], + "mean_absolute_error": [0.011908415300546453], + "mean_absolute_percentage_error": [0.0882205870282268], + "mean_normalized_mean_absolute_error": [0.08814209475433238], + "mean_normalized_root_mean_squared_error": [0.08996232968540896], + "mean_percentage_error": [-0.08717281243113986], + "mean_signed_error": [-0.011777460658723765], + "mean_squared_error": [0.00014772792439308438], + "range_normalized_mean_absolute_error": [0.16772415916262606], + "range_normalized_root_mean_squared_error": [0.17118785462101266], + "root_mean_squared_error": [0.0121543376780919], + "symmetric_mean_absolute_percentage_error": [0.09215897319648417], + }, # One more for a multi band example + { + "band": ["1", "2"], + "coefficient_of_determination": [-1.4498682989135663, -0.7514062048150743], + "mean_absolute_error": [0.025393391237534115, 0.10266655092378396], + "mean_absolute_percentage_error": [0.20440844788169352, np.inf], + "mean_normalized_mean_absolute_error": [ + 0.20592052600829783, + 1.5904259451440834, + ], + "mean_normalized_root_mean_squared_error": [ + 0.2110757427848459, + 2.8406238608292003, + ], + "mean_percentage_error": [-0.20540028455073725, 0.8574267097258231], + "mean_signed_error": [-0.025329236900295846, 0.05534935042165941], + "mean_squared_error": [0.0006775147935436701, 0.03362470648587737], + "range_normalized_mean_absolute_error": [ + 0.31741739046917644, + 0.06341747539921179, + ], + "range_normalized_root_mean_squared_error": [ + 0.32536392930255564, + 0.11326852052594609, + ], + "root_mean_squared_error": [0.026029114344204452, 0.18337040787945413], + "symmetric_mean_absolute_percentage_error": [ + 0.22778286629345662, + 0.8343404150271029, + ], + }, +] + + +@parametrize( + "url, collection, bbox, time, bands, time_aggregate, nodata_fill, expected_df", + list( + zip( + [url] * len(time), + [collection] * len(time), + [bbox] * len(time), + time, + bands, + time_aggreagte, + nodata_fill, + expected_df, + ) + ), +) +def case_stac_api_call( + url, collection, bbox, time, bands, time_aggregate, nodata_fill, expected_df +): + return ( + url, + collection, + bbox, + time, + bands, + time_aggregate, + nodata_fill, + pd.DataFrame(expected_df), + ) + + +bands_fail = [["aot"], ["aot"], ["red"]] + +time_fail = [ + ["1945-04-01", "1945-04-03"], + ["2020-04-01/2020-04-03", "2020-04-06/2020-04-08"], + ["2020-04-01", "2020-04-03"], +] + +time_aggreagte_fail = [None, None, None] + +nodata_fill_fail = [ + None, + None, + None, +] + +exceptions = [ValueError] * 3 + + +@parametrize( + "url, collection, bbox, time, bands, time_aggregate, nodata_fill, exception", + list( + zip( + [url] * len(time), + [collection] * len(time), + [bbox] * len(time), + time_fail, + bands_fail, + time_aggreagte_fail, + nodata_fill_fail, + exceptions, + ) + ), +) +def case_stac_api_call_fail( + url, collection, bbox, time, bands, time_aggregate, nodata_fill, exception +): + return url, collection, bbox, time, bands, time_aggregate, nodata_fill, exception diff --git a/tests/conftest.py b/tests/conftest.py index 75ad4cce..ab32f553 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -44,10 +44,7 @@ def _build_map_file_path(file_name: Union[str, os.PathLike]) -> Union[str, os.Pa def _load_gpkg( - file_name: Union[str, os.PathLike], - *args, - engine: str = "pyogrio", - **kwargs + file_name: Union[str, os.PathLike], *args, engine: str = "pyogrio", **kwargs ) -> gpd.GeoDataFrame: """ Loads geopackage given a base file name. @@ -65,7 +62,7 @@ def _load_gpkg( geopandas GeoDataFrame. """ file_path = _build_map_file_path(file_name) - + # pop engine from kwargs if it exists if "engine" in kwargs: engine = kwargs.pop("engine") diff --git a/tests/test_stac.py b/tests/test_stac.py new file mode 100644 index 00000000..3af1d0ba --- /dev/null +++ b/tests/test_stac.py @@ -0,0 +1,91 @@ +from pytest_cases import parametrize_with_cases +from pytest import raises +import xarray as xr +import pandas as pd + +from gval.utils.loading_datasets import get_stac_data + + +@parametrize_with_cases( + "url, collection, bbox, time, bands, time_aggregate, nodata_fill, expected_df", + glob="stac_api_call", +) +def test_stac_api_call( + url, collection, bbox, time, bands, time_aggregate, nodata_fill, expected_df +): + """ + Tests call for stac API, (IDK if this data can be mocked, API calls in unit tests are dubious) + """ + + candidate = get_stac_data( + url=url, + collection=collection, + time=time[0], + bands=bands, + bbox=bbox, + time_aggregate=time_aggregate, + nodata_fill=nodata_fill, + ) + + benchmark = get_stac_data( + url=url, + collection=collection, + time=time[1], + bands=bands, + bbox=bbox, + time_aggregate=time_aggregate, + nodata_fill=nodata_fill, + ) + + # Registered metrics from previous tests affect this comparison so metrics are explicit + agreement, metrics = candidate.gval.continuous_compare( + benchmark, + metrics=[ + "coefficient_of_determination", + "mean_absolute_error", + "mean_absolute_percentage_error", + "mean_normalized_mean_absolute_error", + "mean_normalized_root_mean_squared_error", + "mean_percentage_error", + "mean_signed_error", + "mean_squared_error", + "range_normalized_mean_absolute_error", + "range_normalized_root_mean_squared_error", + "root_mean_squared_error", + "symmetric_mean_absolute_percentage_error", + ], + ) + + bnds = [bands] if isinstance(bands, str) else bands + + assert isinstance(agreement, xr.Dataset) + assert bnds == [ + agreement[var].attrs["original_name"] for var in agreement.data_vars + ] + + pd.testing.assert_frame_equal( + metrics, expected_df, check_dtype=False + ), "Compute statistics did not return expected values" + + +@parametrize_with_cases( + "url, collection, bbox, time, bands, time_aggregate, nodata_fill, exception", + glob="stac_api_call_fail", +) +def test_stac_api_call_fail( + url, collection, bbox, time, bands, time_aggregate, nodata_fill, exception +): + """ + Tests call for stac API fail + """ + + with raises(exception): + _ = get_stac_data( + url=url, + collection=collection, + time=time[0], + bands=bands, + bbox=bbox, + time_aggregate=time_aggregate, + nodata_fill=nodata_fill, + )